The Atari Compendium/The Atari Compendium (Toad Computers) (1994).iso/files/prgtools/editors/emcs1857/emacsb2.zoo/doc-18.57

Text File | 1992-06-10 | 214.5 KB | 3,781 lines

Fopen-termscript
Start writing all terminal output to FILE as well as the terminal.
FILE = nil means just close any termscript file currently open.Fset-screen-height
Tell redisplay that the screen has LINES lines.
Optional second arg non-nil means that redisplay should use LINES lines
but that the idea of the actual height of the screen should not be changed.Fset-screen-width
Tell redisplay that the screen has COLS columns.
Optional second arg non-nil means that redisplay should use COLS columns
but that the idea of the actual width of the screen should not be changed.Fscreen-height
Return number of lines on screen available for display.Fscreen-width
Return number of columns on screen available for display.Fbaud-rate
Return the output baud rate of the terminal.Fsend-string-to-terminal
Send STRING to the terminal without alteration.
Control characters in STRING will have terminal-dependent effects.Fding
Beep, or flash the screen.
Terminates any keyboard macro currently executing unless an argument
is given.Fsleep-for
Pause, without updating display, for ARG seconds.Fsit-for
Perform redisplay, then wait for ARG seconds or until input is available.
Optional second arg non-nil means don't redisplay.
Redisplay is preempted as always if input arrives, and does not happen
if input is available before it starts.
Value is t if waited the full time with no input arriving.Vinverse-video
*Non-nil means use inverse-video.Vvisible-bell
*Non-nil means try to flash the screen to represent a bell.Vno-redraw-on-reenter
*Non-nil means no need to redraw entire screen after suspending.
It is up to you to set this variable to inform Emacs.Vwindow-system
A symbol naming the window-system under which Emacs is running,
(such as `x'), or nil if emacs is running on an ordinary terminal.Vwindow-system-version
Version number of the window system Emacs is running under.Vcursor-in-echo-area
Non-nil means put cursor in minibuffer after any message displayed there.Fredraw-display
Clear the screen and output again what is supposed to appear on it.Vglobal-mode-string
String displayed by mode-line-format's "%m" specifiation.Voverlay-arrow-position
Marker for where to display an arrow on top of the buffer text.
This must be the beginning of a line in order to work.
See also overlay-arrow-string.Voverlay-arrow-string
String to display as an arrow.  See also overlay-arrow-position.Vscroll-step
*The number of lines to try scrolling a window by when point moves out.
If that fails to bring point back on screen, point is centered instead.
If this is zero, point is always centered after it moves off screen.Vreset-terminal-on-clear
Non-nil means re-init terminal modes for clear screen as on entry to Emacs.Vdebug-end-pos
Don't askVtruncate-partial-width-windows
*Non-nil means truncate lines in all windows less than full screen wide.Vmode-line-inverse-video
*Non-nil means use inverse video, or other suitable display mode, for the mode line.Fwindowp
Returns t if OBJ is a window.Fselected-window
Return the window that the cursor now appears in and commands apply to.Fminibuffer-window
Return the window used for minibuffers.Fpos-visible-in-window-p
Return t if position POS is currently on the screen in WINDOW.
Returns nil if that position is scrolled vertically out of view.
POS defaults to point; WINDOW, to the selected window.Fwindow-buffer
Return the buffer that WINDOW is displaying.Fwindow-height
Return the number of lines in WINDOW (including its mode line).Fwindow-width
Return the number of columns in WINDOW.Fwindow-hscroll
Return the number of columns by which WINDOW is scrolled from left margin.Fset-window-hscroll
Set number of columns WINDOW is scrolled from left margin to NCOL.
NCOL should be zero or positive.Fwindow-edges
Return a list of the edge coordinates of WINDOW.
(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of screen.
RIGHT is one more than the rightmost column used by WINDOW,
and BOTTOM is one more than the bottommost row used by WINDOW
 and its mode-line.Fwindow-point
Return current value of point in WINDOW.
For a nonselected window, this is the value point would have
if that window were selected.

Note that, when WINDOW is the selected window and its buffer
is also currently selected, the value returned is the same as (point).
It would be more strictly correct to return the `top-level' value
of point, outside of any  save-excursion  forms.
But that is hard to define.Fwindow-start
Return position at which display currently starts in WINDOW.Fset-window-point
Make point value in WINDOW be at position POS in WINDOW's buffer.Fset-window-start
Make display in WINDOW start at position POS in WINDOW's buffer.
Optional third arg NOFORCE non-nil inhibits next redisplay
from overriding motion of point in order to display at this exact start.Fdelete-window
Remove WINDOW from the display.  Default is selected window.Fnext-window
Return next window after WINDOW in canonical ordering of windows.
Optional second arg MINIBUF t means count the minibuffer window
even if not active.  If MINIBUF is neither t nor nil it means
not to count the minibuffer even if it is active.Fprevious-window
Return previous window before WINDOW in canonical ordering of windows.Fother-window
Select the ARG'th different window.Fget-lru-window
Return the window least recently selected or used for display.Fget-largest-window
Return the largest window in area.Fget-buffer-window
Return a window currently displaying BUFFER, or nil if none.Fdelete-other-windows
Make WINDOW (or the selected window) fill the screen.Fdelete-windows-on
Delete all windows showing BUFFER.Freplace-buffer-in-windows
Replace BUFFER with some other buffer in all windows showing it.Fset-window-buffer
Make WINDOW display BUFFER as its contents.
BUFFER can be a buffer or buffer name.Fselect-window
Select WINDOW.  Most editing will apply to WINDOW's buffer.
The main editor command loop selects the buffer of the selected window
before each command.Fdisplay-buffer
Make BUFFER appear in some window but don't select it.
BUFFER can be a buffer or a buffer name.
If BUFFER is shown already in some window, just uses that one,
unless the window is the selected window and NOTTHISWINDOW is non-nil.
Returns the window displaying BUFFER.Fsplit-window
Split WINDOW, putting SIZE lines in the first of the pair.
WINDOW defaults to selected one and SIZE to half its size.
If optional third arg HOR-FLAG is non-nil, split side by side
and put SIZE columns in the first of the pair.Fenlarge-window
Make current window ARG lines bigger.
From program, optional second arg non-nil means grow sideways ARG columns.Fshrink-window
Make current window ARG lines smaller.
From program, optional second arg non-nil means shrink sideways ARG columns.Fscroll-up
Scroll text of current window upward ARG lines; or near full screen if no ARG.
When calling from a program, supply a number as argument or nil.Fscroll-down
Scroll text of current window downward ARG lines; or near full screen if no ARG.
When calling from a program, supply a number as argument or nil.Fscroll-left
Scroll selected window display ARG columns left.
Default for ARG is window width minus 2.Fscroll-right
Scroll selected window display ARG columns right.
Default for ARG is window width minus 2.Fscroll-other-window
Scroll text of next window upward ARG lines; or near full screen if no ARG.
The next window is the one below the current one; or the one at the top
if the current one is at the bottom.
When calling from a program, supply a number as argument or nil.Frecenter
Center point in window and redisplay screen.  With ARG, put point on line ARG.
The desired position of point is always relative to the current window.
Just C-u as prefix means put point in the center of the screen.
No arg (i.e., it is nil) erases the entire screen and then
redraws with point in the center.Fmove-to-window-line
Position point relative to window.
With no argument, position at text at center of window.
An argument specifies screen line; zero means top of window,
negative means relative to bottom of window.Fset-window-configuration
Restore the configuration of Emacs' windows and buffers to
the state specified by CONFIGURATION.  CONFIGURATION must be a value
retrned by  current-window-configuration  -- see the documentation of that
function for more information.Fcurrent-window-configuration
Return an object representing Emacs' current window configuration,
namely the number of windows, their sizes and current buffers, and for
each displayed buffer, where display starts, and the positions of
point and mark.  An exception is made for point in (current-buffer) --
its value is -not- saved.Fsave-window-excursion
Execute body, preserving window sizes and contents.
Restores which buffer appears in which window, where display starts,
as well as the current buffer.
Does not restore the value of point in current buffer.Vtemp-buffer-show-hook
Non-nil means call as function to display a help buffer.
Used by with-output-to-temp-buffer.Vminibuffer-scroll-window
Non-nil means it is the window that C-M-v in minibuffer should scroll.Vpop-up-windows
*Non-nil means display-buffer should make new windows.Vnext-screen-context-lines
*Number of lines of continuity when scrolling by screenfuls.Vsplit-height-threshold
*display-buffer would prefer to split the largest window if this large.
If there is only one window, it is split regardless of this value.Vwindow-min-height
*Delete any window less than this tall (including its mode line).Vwindow-min-width
*Delete any window less than this wide.Fkill-emacs
Exit the Emacs job and kill it.  ARG means no query.
If emacs is running noninteractively and ARG is an integer,
return ARG as the exit program code.Fdump-emacs-data
Dump current state of Emacs into data file FILENAME.
This function exists on systems that use HAVE_SHM.Fdump-emacs
Dump current state of Emacs into executable file FILENAME.
Take symbols from SYMFILE (presumably the file you executed to run Emacs).Vcommand-line-args
Args passed by shell to Emacs, as a list of strings.Vsystem-type
Symbol indicating type of operating system you are using.Vnoninteractive
Non-nil means Emacs is running without interactive terminal.Vkill-emacs-hook
Function called, if non-nil, whenever kill-emacs is called.Frecursive-edit
Invoke the editor command loop recursively.
Do (throw 'exit nil) within the command loop to make this function return,
or (throw 'exit t) to make this function signal an error.
This function is called by the editor initialization
to begin editing.Ftop-level
Exit all recursive editing levels.Fexit-recursive-edit
Exit from the innermost recursive edit or minibuffer.Fabort-recursive-edit
Abort the command that requested this recursive edit or minibuffer input.Fread-key-sequence
Read a sequence of keystrokes and return as a string.
The sequence is sufficient to specify a non-prefix command
starting from the current local and global keymaps.
A C-g typed while in this function is treated like
any other character, and quit-flag is not set.
One arg, PROMPT, a prompt string or  nil, meaning do not prompt specially.Fcommand-execute
Execute CMD as an editor command.
CMD must be a symbol that satisfies the `commandp' predicate.
Optional second arg RECORD-FLAG non-nil
means unconditionally put this command in the command-history.
Otherwise, this is done only if an arg is read using the minibuffer.Fexecute-extended-command
Read function name, then read its arguments and call it.Finput-pending-p
T if command input is currently available with no waiting.
Actually, the value is NIL only if we can be sure that no input is available.Frecent-keys
Return string of last 100 chars read from terminal.Fthis-command-keys
Return string of the keystrokes that invoked this command.Frecursion-depth
Return the current depth in recursive edits.Fopen-dribble-file
Start writing all keyboard characters to FILE.Fdiscard-input
Discard the contents of the terminal input buffer.
Also flush any kbd macro definition in progress.Fsuspend-emacs
Stop Emacs and return to superior process.  You can resume.
If optional arg STUFFSTRING is non-nil, its characters are stuffed
to be read as terminal input by Emacs's superior shell.
Before suspending, if `suspend-hook' is bound and value is non-nil
call the value as a function of no args.  Don't suspend if it returns non-nil.
Otherwise, suspend normally and after resumption call
`suspend-resume-hook' if that is bound and non-nil.Fset-input-mode
Set mode of reading keyboard input.
First arg non-nil means use input interrupts; nil means use CBREAK mode.
Second arg non-nil means use ^S/^Q flow control for output to terminal
 (no effect except in CBREAK mode).
Optional third arg non-nil specifies character to use for quitting.

Note that the arguments will change incompatibly in version 19.Vdisabled-command-hook
Value is called instead of any command that is disabled
(has a non-nil  disabled  property).Vmeta-flag
*Non-nil means treat 0200 bit in terminal input as Meta bit.Vlast-command-char
Last terminal input character that was part of a command, as an integer.Vlast-input-char
Last terminal input character, as an integer.Vunread-command-char
Character to be read as next input from command input stream, or -1 if none.Vmeta-prefix-char
Meta-prefix character code.  Meta-foo as command input
turns into this character followed by foo.Vlast-command
The last command executed.  Normally a symbol with a function definition,
but can be whatever was found in the keymap, or whatever the variable
`this-command' was set to by that command.Vthis-command
The command now being executed.
The command can set this variable; whatever is put here
will be in  last-command  during the following command.Vauto-save-interval
*Number of keyboard input characters between auto-saves.
Zero means disable autosaving.Vecho-keystrokes
*Nonzero means echo unfinished commands after this many seconds of pause.Vpolling-period
*Interval between polling for input during Lisp execution.
The reason for polling is to make C-g work to stop a running program.
Polling is needed only when using X windows and SIGIO does not work.
Polling is automatically disabled in all other cases.Vhelp-char
Character to recognize as meaning Help.
When it is read, do (eval help-form), and display result if it's a string.
If help-form's value is nil, this char can be read normally.Vhelp-form
Form to execute when character help-char is read.
If the form returns a string, that string is displayed.
If help-form is nil, the help char is not recognized.Vtop-level
Form to evaluate when Emacs starts up.
Useful to set before you dump a modified Emacs.Vkeyboard-translate-table
String used as translate table for keyboard input, or nil.
Each character is looked up in this string and the contents used instead.
If string is of length N, character codes N and up are untranslated.Fstart-kbd-macro
Record subsequent keyboard input, defining a keyboard macro.
The commands are recorded even as they are executed.
Use \[end-kbd-macro] to finish recording and make the macro available.
Use \[name-last-kbd-macro] to give it a permanent name.
Non-nil arg (prefix arg) means append to last macro defined;
 This begins by re-executing that macro as if you typed it again.Fend-kbd-macro
Finish defining a keyboard macro.
The definition was started by \[start-kbd-macro].
The macro is now available for use via \[call-last-kbd-macro],
or it can be given a name with \[name-last-kbd-macro] and then invoked
under that name.
With numeric arg, repeat macro now that many times,
counting the definition just completed as the first repetition.Fcall-last-kbd-macro
Call the last keyboard macro that you defined with \[start-kbd-macro].
To make a macro permanent so you can call it even after
defining others, use \[name-last-kbd-macro].Fexecute-kbd-macro
Execute MACRO as string of editor command characters.
If MACRO is a symbol, its function definition is used.
COUNT is a repeat count, or nil for once, or 0 for infinite loop.Vdefining-kbd-macro
Non-nil means store keyboard input into kbd macro being defined.Vexecuting-macro
Currently executing keyboard macro (a string); nil if none executing.Vexecuting-kbd-macro
Currently executing keyboard macro (a string); nil if none executing.Vlast-kbd-macro
Last kbd macro defined, as a string; nil if none defined.Fmake-keymap
Construct and return a new keymap, a vector of length 128.
All entries in it are nil, meaning "command undefined".Fmake-sparse-keymap
Construct and return a new sparse-keymap list.
Its car is 'keymap and its cdr is an alist of (CHAR . DEFINITION).
Initially the alist is nil.Fkeymapp
Return t if ARG is a keymap.
A keymap is a vector of length 128, or a list (keymap . ALIST),
where alist elements look like (CHAR . DEFN).Fcopy-keymap
Return a copy of the keymap KEYMAP.
The copy starts out with the same definitions of KEYMAP,
but changing either the copy or KEYMAP does not affect the other.
Any key definitions that are subkeymaps are recursively copied.Fdefine-key
Args KEYMAP, KEY, DEF.  Define key sequence KEY, in KEYMAP, as DEF.
KEYMAP is a keymap.  KEY is a string meaning a sequence of keystrokes.
DEF is anything that can be a key's definition:
 nil (means key is undefined in this keymap),
 a command (a Lisp function suitable for interactive calling)
 a string (treated as a keyboard macro),
 a keymap (to define a prefix key),
 a list (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP,
 or a symbol.  The symbol's function definition is used as the key's
definition, and may be any of the above (including another symbol).Flookup-key
In keymap KEYMAP, look up key sequence KEY.  Return the definition.
nil means undefined.  See doc of define-key for kinds of definitions.
Number as value means KEY is "too long";
that is, characters in it except for the last one
fail to be a valid sequence of prefix characters in KEYMAP.
The number is how many characters at the front of KEY
it takes to reach a non-prefix command.Fkey-binding
Return the definition for command KEYS in current keymaps.
KEYS is a string, a sequence of keystrokes.
The definition is probably a symbol with a function definition.Flocal-key-binding
Return the definition for command KEYS in current local keymap only.
KEYS is a string, a sequence of keystrokes.
The definition is probably a symbol with a function definition.Fglobal-key-binding
Return the definition for command KEYS in current global keymap only.
KEYS is a string, a sequence of keystrokes.
The definition is probably a symbol with a function definition.Fglobal-set-key
Give KEY a definition of COMMAND.
COMMAND is a symbol naming an interactively-callable function.
KEY is a string representing a sequence of keystrokes.
Note that if KEY has a local definition in the current buffer
that local definition will continue to shadow any global definition.Flocal-set-key
Give KEY a local definition of COMMAND.
COMMAND is a symbol naming an interactively-callable function.
KEY is a string representing a sequence of keystrokes.
The definition goes in the current buffer's local map,
which is shared with other buffers in the same major mode.Fglobal-unset-key
Remove global definition of KEY.
KEY is a string representing a sequence of keystrokes.Flocal-unset-key
Remove local definition of KEY.
KEY is a string representing a sequence of keystrokes.Fdefine-prefix-command
Define SYMBOL as a prefix command.
A keymap is created and stored as SYMBOL's function definition.Fuse-global-map
Selects KEYMAP as the global keymap.Fuse-local-map
Selects KEYMAP as the local keymap.
nil for KEYMAP means no local keymap.Fcurrent-local-map
Return current buffer's local keymap, or nil if it has none.Fcurrent-global-map
Return the current global keymap.Faccessible-keymaps
Find all keymaps accessible via prefix characters from KEYMAP.
Returns a list of elements of the form (KEYS . MAP), where the sequence
KEYS starting from KEYMAP gets you to MAP.  These elements are ordered
so that the KEYS increase in length.  The first element is ("" . KEYMAP).Fkey-description
Return a pretty description of key-sequence KEYS.
Control characters turn into "C-foo" sequences, meta into "M-foo"
spaces are put between sequence elements, etc.Fsingle-key-description
Return a pretty description of command character KEY.
Control characters turn into C-whatever, etc.Ftext-char-description
Return a pretty description of file-character CHAR.
Control characters turn into "^char", etc.Fwhere-is-internal
Return list of key sequences that currently invoke command DEFINITION
in KEYMAP or (current-global-map).  If KEYMAP is nil, only search for
keys in the global map.

If FIRSTONLY is non-nil, returns a string representing the first key
sequence found, rather than a list of all possible key sequences.Fwhere-is
Print message listing key sequences that invoke specified command.
Argument is a command definition, usually a symbol with a function definition.Fdescribe-bindings
Show a list of all defined keys, and their definitions.
The list is put in a buffer, which is displayed.Fapropos
Show all symbols whose names contain match for REGEXP.
If optional arg PRED is non-nil, (funcall PRED SYM) is done
for each symbol and a symbol is mentioned if that returns non-nil.
Returns list of symbols found; if third arg NOPRINT is non-nil,
does not display them, just returns the list.Vminibuffer-local-map
Default keymap to use when reading from the minibuffer.Vminibuffer-local-ns-map
The keymap used by the minibuf for local bindings when spaces are not
to be allowed in input string.Vminibuffer-local-completion-map
Keymap to use when reading from the minibuffer with completion.Vminibuffer-local-must-match-map
Keymap to use when reading from the minibuffer with completion and
an exact match of one of the completions is required.Fbuffer-list
Return a list of all buffers.Fget-buffer
Return the buffer named NAME (a string).
It is found by looking up NAME in  buffer-alist.
If there is no buffer named NAME, nil is returned.
NAME may also be a buffer; it is returned.Fget-file-buffer
Return the buffer visiting file FILENAME (a string).
If there is no such buffer, nil is returned.Fget-buffer-create
Like get-buffer but creates a buffer named NAME and returns it if none already exists.Fgenerate-new-buffer
Creates and returns a buffer named NAME if one does not already exist,
else tries adding successive suffixes to NAME until a new buffer-name is
formed, then creates and returns a new buffer with that new name.Fbuffer-name
Return the name of BUFFER, as a string.
No arg means return name of current buffer.Fbuffer-file-name
Return name of file BUFFER is visiting, or NIL if none.
No argument means use current buffer as BUFFER.Fbuffer-local-variables
Return alist of variables that are buffer-local in BUFFER.
No argument means use current buffer as BUFFER.
Each element of the value looks like (SYMBOL . VALUE).
Note that storing new VALUEs in these elements
does not change the local values.Fbuffer-modified-p
Return t if BUFFER is modified since file last read in or saved.
No argument means use current buffer as BUFFER.Fset-buffer-modified-p
Mark current buffer as modified or unmodified according to FLAG.Frename-buffer
Change current buffer's name to NEWNAME (a string).Fother-buffer
Return most recently selected buffer other than BUFFER.
Buffers not visible in windows are preferred to visible buffers.
If no other exists, the buffer *scratch* is returned.
If BUFFER is omitted or nil, some interesting buffer is returned.Fbuffer-flush-undo
Make BUFFER stop keeping undo information.Fbuffer-enable-undo
Start keeping undo information for buffer BUFFER (default is current buffer).Fkill-buffer
One arg, a string or a buffer.  Get rid of the specified buffer.
Any processes that have this buffer as the `process-buffer' are killed
with `delete-process'.Fswitch-to-buffer
Select buffer BUFFER in the current window.
BUFFER may be a buffer or a buffer name.
Optional second arg NORECORD non-nil means
do not put this buffer at the front of the list of recently selected ones.

WARNING: This is NOT the way to work on another buffer temporarily
within a Lisp program!  Use `set-buffer' instead.  That avoids messing with
the window-buffer correspondances.Fpop-to-buffer
Select buffer BUFFER in some window, preferably a different one.
If  pop-up-windows  is non-nil, windows can be split to do this.
If second arg  OTHER-WINDOW is non-nil, insist on finding another
window even if BUFFER is already visible in the selected window.Fcurrent-buffer
Return the current buffer as a Lisp buffer object.Fset-buffer
Set the current buffer to the buffer or buffer name supplied as argument.
That buffer will then be the default for editing operations and printing.
This function's effect can't last past end of current command
because returning to command level
selects the chosen buffer of the current window,
and this function has no effect on what buffer that is.
See also `save-excursion' when you want to select a buffer temporarily.
Use `switch-to-buffer' or `pop-to-buffer' for interactive buffer selection.Fbarf-if-buffer-read-only
Signal a  buffer-read-only  error if the current buffer is read-only.Fbury-buffer
Put BUFFER at the end of the list of all buffers.
There it is the least likely candidate for other-buffer to return;
thus, the least likely buffer for \[switch-to-buffer] to select by default.Ferase-buffer
Delete the entire contents of the current buffer.Flist-buffers
Display a list of names of existing buffers.
Inserts it in buffer *Buffer List* and displays that.
Note that buffers with names starting with spaces are omitted.
Non-null optional arg FILES-ONLY means mention only file buffers.

The M column contains a * for buffers that are modified.
The R column contains a % for buffers that are read-only.Fkill-all-local-variables
Eliminate all the buffer-local variable values of the current buffer.
This buffer will then see the default values of all variables.Vdefault-mode-line-format
Default mode-line-format for buffers that do not override it.
This is the same as (default-value 'mode-line-format).Vdefault-abbrev-mode
Default abbrev-mode for buffers that do not override it.
This is the same as (default-value 'abbrev-mode).Vdefault-ctl-arrow
Default ctl-arrow for buffers that do not override it.
This is the same as (default-value 'ctl-arrow).Vdefault-truncate-lines
Default truncate-lines for buffers that do not override it.
This is the same as (default-value 'truncate-lines).Vdefault-fill-column
Default fill-column for buffers that do not override it.
This is the same as (default-value 'fill-column).Vdefault-left-margin
Default left-margin for buffers that do not override it.
This is the same as (default-value 'left-margin).Vdefault-tab-width
Default tab-width for buffers that do not override it.
This is the same as (default-value 'tab-width).Vdefault-case-fold-search
Default case-fold-search for buffers that do not override it.
This is the same as (default-value 'case-fold-search).Vmode-line-format
Template for displaying mode line for current buffer.
Each buffer has its own value of this variable.
Value may be a string, a symbol or a list or cons cell.
For a symbol, its value is used (but it is ignored if t or nil).
 A string appearing directly as the value of a symbol is processed verbatim
 in that the %-constructs below are not recognized.
For a list whose car is a symbol, the symbol's value is taken,
 and if that is non-nil, the cadr of the list is processed recursively.
 Otherwise, the caddr of the list (if there is one) is processed.
For a list whose car is a string or list, each element is processed
 recursively and the results are effectively concatenated.
For a list whose car is an integer, the cdr of the list is processed
  and padded (if the number is positive) or truncated (if negative)
  to the width specified by that number.
A string is printed verbatim in the mode line except for %-constructs:
  (%-constructs are allowed when the string is the entire mode-line-format
   or when it is found in a cons-cell or a list)
  %b -- print buffer name.      %f -- print visited file name.
  %* -- print *, % or hyphen.   %m -- print value of mode-name (obsolete).
  %s -- print process status.   %M -- print value of global-mode-string. (obs)
  %p -- print percent of buffer above top of window, or top, bot or all.
  %n -- print Narrow if appropriate.
  %[ -- print one [ for each recursive editing level.  %] similar.
  %% -- print %.   %- -- print infinitely many dashes.
Decimal digits after the % specify field width to which to pad.Vdefault-major-mode
*Major mode for new buffers.  Defaults to fundamental-mode.
nil here means use current buffer's major mode.Vmajor-mode
Symbol for current buffer's major mode.Vabbrev-mode
Non-nil turns on automatic expansion of abbrevs when inserted.
Automatically becomes local when set in any fashion.Vcase-fold-search
*Non-nil if searches should ignore case.
Automatically becomes local when set in any fashion.Vmode-name
Pretty name of current buffer's major mode (a string).Vfill-column
*Column beyond which automatic line-wrapping should happen.
Automatically becomes local when set in any fashion.Vleft-margin
*Column for the default indent-line-function to indent to.
Linefeed indents to this column in Fundamental mode.
Automatically becomes local when set in any fashion.Vtab-width
*Distance between tab stops (for display of tab characters), in columns.
Automatically becomes local when set in any fashion.Vctl-arrow
*t means display control chars with uparrow.
Nil means use backslash and octal digits.
Otherwise assume that control and meta chars are printable.
Automatically becomes local when set in any fashion.

This is an Ergo local feature.Vtruncate-lines
*Non-nil means do not display continuation lines;
give each line of text one screen line.
Automatically becomes local when set in any fashion.

Note that this is overridden by the variable
truncate-partial-width-windows if that variable is non-nil
and this buffer is not full-screen width.Vdefault-directory
Name of default directory of current buffer.  Should end with slash.Vauto-fill-hook
Function called (if non-nil) after self-inserting a space at column beyond fill-columnVbuffer-file-name
Name of file visited in current buffer, or nil if not visiting a file.Vbuffer-auto-save-file-name
Name of file for auto-saving current buffer,
or nil if buffer should not be auto-saved.Vbuffer-read-only
Non-nil if this buffer is read-only.Vbuffer-backed-up
Non-nil if this buffer's file has been backed up.
Backing up is done before the first time the file is saved.Vbuffer-saved-size
Length of current buffer when last read in, saved or auto-saved.
0 initially.Vselective-display
t enables selective display:
 after a ^M, all the rest of the line is invisible.
 ^M's in the file are written into files as newlines.
Integer n as value means display only lines
 that start with less than n columns of space.
Automatically becomes local when set in any fashion.Vselective-display-ellipses
t means display ... on previous line when a line is invisible.
Automatically becomes local when set in any fashion.Voverwrite-mode
Non-nil if self-insertion should replace existing text.
Automatically becomes local when set in any fashion.Vbuffer-undo-list
List of undo entries in current buffer.Flock-buffer
Locks FILE, if current buffer is modified.
FILE defaults to current buffer's visited file,
or else nothing is done if current buffer isn't visiting a file.Funlock-buffer
Unlocks the file visited in the current buffer,
if it should normally be locked.Ffile-locked-p
Returns nil if the FILENAME is not locked,
t if it is locked by you, else a string of the name of the locker.Fmarker-buffer
Return the buffer that MARKER points into, or nil if none.
Returns nil if MARKER points into a dead buffer.Fmarker-position
Return the position MARKER points at, as a character number.Fset-marker
Position MARKER before character number NUMBER in BUFFER.
BUFFER defaults to the current buffer.
If NUMBER is nil, makes marker point nowhere.
Then it no longer slows down editing in any buffer.
Returns MARKER.Fcopy-marker
Return a new marker pointing at the same place as MARKER.
If argument is a number, makes a new marker pointing
at that position in the current buffer.Fread-from-minibuffer
Read a string from the minibuffer, prompting with string PROMPT.
If optional second arg INITIAL-CONTENTS is non-nil, it is a string
  to be inserted into the minibuffer before reading input.
Third arg KEYMAP is a keymap to use whilst reading; the default is
  minibuffer-local-map.
If fourth arg READ is non-nil, then interpret the result as a lisp object
  and return that object  (ie  (car (read-from-string <input-string>)))Fread-minibuffer
Return a Lisp object read using the minibuffer.
Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
is a string to insert in the minibuffer before reading.Feval-minibuffer
Return value of Lisp expression read using the minibuffer.
Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
is a string to insert in the minibuffer before reading.Fread-string
Read a string from the minibuffer, prompting with string PROMPT.
If non-nil second arg INITIAL-INPUT is a string to insert before reading.Fread-no-blanks-input
Args PROMPT and INIT, strings.  Read a string from the terminal, not allowing blanks.
Prompt with PROMPT, and provide INIT as an initial value of the input string.Fread-command
One arg PROMPT, a string.  Read the name of a command and return as a symbol.
Prompts with PROMPT.Fread-function
One arg PROMPT, a string.  Read the name of a function and return as a symbol.
Prompts with PROMPT.Fread-variable
One arg PROMPT, a string.  Read the name of a user variable and return
it as a symbol.  Prompts with PROMPT.
A user variable is one whose documentation starts with a "*" character.Fread-buffer
One arg PROMPT, a string.  Read the name of a buffer and return as a string.
Prompts with PROMPT.
Optional second arg is value to return if user enters an empty line.
If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.Ftry-completion
Return common substring of all completions of STRING in ALIST.
Each car of each element of ALIST is tested to see if it begins with STRING.
All that match are compared together; the longest initial sequence
common to all matches is returned as a string.
If there is no match at all, nil is returned.
For an exact match, t is returned.

ALIST can be an obarray instead of an alist.
Then the print names of all symbols in the obarray are the possible matches.

If optional third argument PREDICATE is non-nil,
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element or the symbol from the obarray.Fall-completions
Search for partial matches to STRING in ALIST.
Each car of each element of ALIST is tested to see if it begins with STRING.
The value is a list of all the strings from ALIST that match.
ALIST can be an obarray instead of an alist.
Then the print names of all symbols in the obarray are the possible matches.

If optional third argument PREDICATE is non-nil,
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element or the symbol from the obarray.Fcompleting-read
Read a string in the minibuffer, with completion.
Args are PROMPT, TABLE, PREDICATE, REQUIRE-MATCH and INITIAL-INPUT.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
TABLE is an alist whose elements' cars are strings, or an obarray (see try-completion).
PREDICATE limits completion to a subset of TABLE; see try-completion for details.
If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
 the input is (or completes to) an element of TABLE.
 If it is also not t, Return does not exit if it does non-null completion.
If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
Case is ignored if ambient value of  completion-ignore-case  is non-nil.Fminibuffer-complete
Complete the minibuffer contents as far as possible.Fminibuffer-complete-and-exit
Complete the minibuffer contents, and maybe exit.
Exit if the name is valid with no completion needed.
If name was completed to a valid match,
a repetition of this command will exit.Fminibuffer-complete-word
Complete the minibuffer contents at most a single word.Fdisplay-completion-list
Display in a buffer the list of completions, COMPLETIONS.
Each element may be just a symbol or string
or may be a list of two strings to be printed as if concatenated.Fminibuffer-completion-help
Display a list of possible completions of the current minibuffer contents.Fself-insert-and-exit
Terminate minibuffer input.Fexit-minibuffer
Terminate this minibuffer argument.Fminibuffer-depth
Return current depth of activations of minibuffer, a nonnegative integer.Vcompletion-auto-help
*Non-nil means automatically provide help for invalid completion input.Vcompletion-ignore-case
Non-nil means don't consider case significant in completion.Venable-recursive-minibuffers
*Non-nil means to allow minibuffers to invoke commands which use
recursive minibuffers.Vminibuffer-completion-table
Alist or obarray used for completion in the minibuffer.Vminibuffer-completion-predicate
Holds PREDICATE argument to completing-read.Vminibuffer-completion-confirm
Non-nil => demand confirmation of completion before exiting minibuffer.Vminibuffer-help-form
Value that help-form takes on inside the minibuffer.Fdirectory-files
Return a list of names of files in DIRECTORY.
If FULL is non-NIL, absolute pathnames of the files are returned.
If MATCH is non-NIL, only pathnames containing that regexp are returned.Ffile-name-completion
Complete file name FILE in directory DIR.
Returns the longest string common to all filenames in DIR
that start with FILE.
If there is only one and FILE matches it exactly, returns t.
Returns nil if DIR contains no name starting with FILE.Ffile-name-all-completions
Return a list of all completions of file name FILE in directory DIR.Ffile-name-all-versions
Return a list of all versions of file name FILE in directory DIR.Ffile-attributes
Return a list of attributes of file FILENAME.
Value is nil if specified file cannot be opened.
Otherwise, list elements are:
 0. t for directory, string (name linked to) for symbolic link, or nil.
 1. Number of links to file.
 2. File uid.
 3. File gid.
 4. Last access time, as a list of two integers.
  First integer has high-order 16 bits of time, second has low 16 bits.
 5. Last modification time, likewise.
 6. Last status change time, likewise.
 7. Size in bytes.
 8. File modes, as a string of ten letters or dashes as in ls -l.
 9. t iff file's gid would change if file were deleted and recreated.
10. inode number.

If file does not exists, returns nil.Vcompletion-ignored-extensions
*Completion ignores filenames ending in any string in this list.Fforward-char
Move point right ARG characters (left if ARG negative).
On reaching end of buffer, stop and signal error.Fbackward-char
Move point left ARG characters (right if ARG negative).
On attempt to pass beginning or end of buffer, stop and signal error.Fforward-line
If point is on line i, move to the start of line i + ARG.
If there isn't room, go as far as possible (no error).
Returns the count of lines left to move.
With positive ARG, a non-empty line at the end counts as one line
  successfully moved (for the return value).Fbeginning-of-line
Move point to beginning of current line.
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If scan reaches end of buffer, stop there without error.Fend-of-line
Move point to end of current line.
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If scan reaches end of buffer, stop there without error.Fdelete-char
Delete the following ARG characters (previous, with negative arg).
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
Interactively, ARG is the prefix arg, and KILLFLAG is set if
ARG was explicitly specified.Fdelete-backward-char
Delete the previous ARG characters (following, with negative ARG).
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
Interactively, ARG is the prefix arg, and KILLFLAG is set if
ARG was explicitly specified.Fself-insert-command
Insert this character.  Prefix arg is repeat-count.Fnewline
Insert a newline.  With arg, insert that many newlines.
In Auto Fill mode, can break the preceding line if no numeric arg.Vblink-paren-hook
Function called, if non-nil, whenever a char with closeparen syntax is self-inserted.Fupcase
One arg, a character or string.  Convert it to upper case and return that.Fdowncase
One arg, a character or string.  Convert it to lower case and return that.Fcapitalize
One arg, a character or string.  Convert it to capitalized form and return that.
This means that each word's first character is upper case and the rest is lower case.Fupcase-region
Convert the region to upper case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.Fdowncase-region
Convert the region to lower case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.Fcapitalize-region
Convert the region to upper case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.
Capitalized form means each word's first character is upper case
and the rest of it is lower case.Fupcase-word
Convert following word (or ARG words) to upper case, moving over.
With negative argument, convert previous words but do not move.Fdowncase-word
Convert following word (or ARG words) to lower case, moving over.
With negative argument, convert previous words but do not move.Fcapitalize-word
Capitalize the following word (or ARG words), moving over.
This gives the word(s) a first character in upper case
and the rest lower case.
With negative argument, capitalize previous words but do not move.Fcurrent-column
Return the horizontal position of point.  Beginning of line is column 0.
This is calculated by adding together the widths of all the displayed
representations of the character between the start of the previous line
and point.  (eg control characters will have a width of 2 or 4, tabs
will have a variable width)
Ignores finite width of screen, which means that this function may return
values greater than (screen-width).
Whether the line is visible (if `selective-display' is t) has no effect.Findent-to
Indent from point with tabs and spaces until COLUMN is reached.
Always do at least MIN spaces even if that goes past COLUMN;
by default, MIN is zero.Fcurrent-indentation
Return the indentation of the current line.
This is the horizontal position of the character
following any initial whitespace.Fmove-to-column
Move point to column COLUMN in the current line.
COLUMN is calculated by adding together the widths of all the displayed
representations of the character between the start of the previous line
and point.  (eg control characters will have a width of 2 or 4, tabs
will have a variable width)
Ignores finite width of screen, which means that this function may be
passed values greater than (screen-width)Fvertical-motion
Move to start of screen line LINES lines down.
If LINES is negative, this is moving up.
Sets point to position found; this may be start of line
 or just the start of a continuation line.
Returns number of lines moved; may be closer to zero than LINES
 if beginning or end of buffer was reached.Vindent-tabs-mode
*Indentation can insert tabs if this is non-nil.
Setting this variable automatically makes it local to the current buffer.Flooking-at
t if text after point matches regular expression PAT.Fstring-match
Return index of start of first match for REGEXP in STRING, or nil.
If third arg START is non-nil, start search at that index in STRING.
For index of first char beyond the match, do (match-end 0).
match-end and match-beginning also give indices of substrings
matched by parenthesis constructs in the pattern.Fskip-chars-forward
Move point forward, stopping before a char not in CHARS, or at position LIM.
CHARS is like the inside of a [...] in a regular expression
except that ] is never special and \ quotes ^, - or \.
Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
With arg "^a-zA-Z", skips nonletters stopping before first letter.Fskip-chars-backward
Move point backward, stopping after a char not in CHARS, or at position LIM.
See skip-chars-forward for details.Fsearch-backward
Search backward from point for STRING.
Set point to the beginning of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
 If not nil and not t, position at limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.Fsearch-forward
Search forward from point for STRING.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.Fword-search-backward
Search backward from point for STRING, ignoring differences in punctuation.
Set point to the beginning of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.Fword-search-forward
Search forward from point for STRING, ignoring differences in punctuation.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.Fre-search-backward
Search backward from point for match for regular expression REGEXP.
Set point to the beginning of the match, and return t.
The match found is the one starting last in the buffer
and yet ending before the place the origin of the search.
An optional second argument bounds the search; it is a buffer position.
The match found must start at or after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions match-beginning and match-end and replace-match.Fre-search-forward
Search forward from point for regular expression REGEXP.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions match-beginning and match-end and replace-match.Freplace-match
Replace text matched by last search with NEWTEXT.
If second arg FIXEDCASE is non-nil, do not alter case of replacement text.
Otherwise convert to all caps or cap initials, like replaced text.
If third arg LITERAL is non-nil, insert NEWTEXT literally.
Otherwise treat \ as special:
  \& in NEWTEXT means substitute original matched text,
  \N means substitute match for \(...\) number N,
  \\ means insert one \.
Leaves point at end of replacement text.Fmatch-beginning
Return the character number of start of text matched by last regexp searched for.
ARG, a number, specifies which parenthesized expression in the last regexp.
 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.
Zero means the entire text matched by the whole regexp.Fmatch-end
Return the character number of end of text matched by last regexp searched for.
ARG, a number, specifies which parenthesized expression in the last regexp.
 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.
Zero means the entire text matched by the whole regexp.Fmatch-data
Return list containing all info on what the last search matched.
Element 2N is (match-beginning N); element 2N + 1 is (match-end N).
All the elements are normally markers, or nil if the Nth pair didn't match.
0 is also possible, when matching was done with `string-match',
if a match began at index 0 in the string.Fstore-match-data
Set internal data on last search match from elements of LIST.
LIST should have been created by calling match-data previously.Fregexp-quote
Return a regexp string which matches exactly STRING and nothing else.Fundo-boundary
Mark a boundary between units of undo.
An undo command will stop at this point,
but another undo command will undo to the previous boundary.Fprimitive-undo
Undo N records from the front of the list LIST.
Return what remains of the list.Fcons
Create a new cons, give it CAR and CDR as components, and return it.Flist
Return a newly created list whose elements are the arguments (any number).Fmake-list
Return a newly created list of length LENGTH, with each element being INIT.Fmake-vector
Return a newly created vector of length LENGTH, with each element being INIT.Fvector
Return a newly created vector with our arguments (any number) as its elements.Fmake-symbol
Return a newly allocated uninterned symbol whose name is NAME.
Its value and function definition are void, and its property list is NIL.Fmake-marker
Return a newly allocated marker which does not point at any place.Fmake-string
Return a newly created string of length LENGTH, with each element being INIT.
Both LENGTH and INIT must be numbers.Fpurecopy
Make a copy of OBJECT in pure storage.
Recursively copies contents of vectors and cons cells.
Does not copy symbols.Fgarbage-collect
Reclaim storage for Lisp objects no longer needed.
Returns info on amount of space in use:
 ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
  (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS)
Garbage collection happens automatically if you cons more than
gc-cons-threshold  bytes of Lisp data since previous garbage collection.Vgc-cons-threshold
*Number of bytes of consing between garbage collections.Vpure-bytes-used
Number of bytes of sharable Lisp data allocated so far.Vdata-bytes-used
Number of bytes of unshared memory allocated in this session.Vdata-bytes-free
Number of bytes of unshared memory remaining available in this session.Vdata-bytes-used
Number of bytes of unshared memory allocated in this session.Vdata-bytes-free
Number of bytes of unshared memory remaining available in this session.Vpurify-flag
Non-nil means loading Lisp code in order to dump an executable.Vundo-threshold
Keep no more undo information once it exceeds this size.
This threshold is applied when garbage collection happens.
The size is counted as the number of bytes occupied,
which includes both saved text and other data.Vundo-high-threshold
Don't keep more than this much size of undo information.
A command which pushes past this size is itself forgotten.
This threshold is applied when garbage collection happens.
The size is counted as the number of bytes occupied,
which includes both saved text and other data.Feq
T if the two args are the same Lisp object.Fnull
T if OBJECT is nil.Fconsp
T if OBJECT is a cons cell.Fatom
T if OBJECT is not a cons cell.  This includes nil.Flistp
T if OBJECT is a list.  This includes nil.Fnlistp
T if OBJECT is not a list.  Lists include nil.Fintegerp
T if OBJECT is a number.Fnatnump
T if OBJECT is a nonnegative number.Fsymbolp
T if OBJECT is a symbol.Fvectorp
T if OBJECT is a vector.Fstringp
T if OBJECT is a string.Farrayp
T if OBJECT is an array (string or vector).Fsequencep
T if OBJECT is a sequence (list or array).Fbufferp
T if OBJECT is an editor buffer.Fmarkerp
T if OBJECT is a marker (editor pointer).Finteger-or-marker-p
T if OBJECT is an integer or a marker (editor pointer).Fsubrp
T if OBJECT is a built-in function.Fchar-or-string-p
T if OBJECT is a character (a number) or a string.Fcar
Return the car of CONSCELL.  If arg is nil, return nil.Fcar-safe
Return the car of OBJECT if it is a cons cell, or else  nil.Fcdr
Return the cdr of CONSCELL.  If arg is nil, return nil.Fcdr-safe
Return the cdr of OBJECT if it is a cons cell, or else  nil.Fsetcar
Set the car of CONSCELL to be NEWCAR.  Returns NEWCAR.Fsetcdr
Set the cdr of CONSCELL to be NEWCDR.  Returns NEWCDR.Fboundp
T if SYMBOL's value is not void.Ffboundp
T if SYMBOL's function definition is not void.Fmakunbound
Make SYMBOL's value be void.Ffmakunbound
Make SYMBOL's function definition be void.Fsymbol-function
Return SYMBOL's function definition.Fsymbol-plist
Return SYMBOL's property list.Fsymbol-name
Return SYMBOL's name, a string.Ffset
Set SYMBOL's function definition to NEWVAL, and return NEWVAL.Fsetplist
Set SYMBOL's property list to NEWVAL, and return NEWVAL.Fsymbol-value
Return SYMBOL's value.Fdefault-value
Return SYMBOL's default value.
This is the value that is seen in buffers that do not have their own values
for this variable.Fset
Set SYMBOL's value to NEWVAL, and return NEWVAL.Fset-default
Set SYMBOL's default value to VAL.  SYMBOL and VAL are evaluated.
The default value is seen in buffers that do not have their own values
for this variable.Fsetq-default
Set SYMBOL's default value to VAL.  VAL is evaluated; SYMBOL is not.
The default value is seen in buffers that do not have their own values
for this variable.Fmake-variable-buffer-local
Make VARIABLE have a separate value for each buffer.
At any time, the value for the current buffer is in effect.
There is also a default value which is seen in any buffer which has not yet
set its own value.
The function `default-value' gets the default value and `set-default' sets it.
Using `set' or `setq' to set the variable causes it to have a separate value
for the current buffer if it was previously using the default value.Fmake-local-variable
Make VARIABLE have a separate value in the current buffer.
Other buffers will continue to share a common default value.
See also `make-variable-buffer-local'.Fkill-local-variable
Make VARIABLE no longer have a separate value in the current buffer.
From now on the default value will apply in this buffer.Faref
Return the element of ARRAY at index INDEX.
ARRAY may be a vector or a string.  INDEX starts at 0.Faset
Store into the element of ARRAY at index INDEX the value NEWVAL.
ARRAY may be a vector or a string.  INDEX starts at 0.F=
T if two args, both numbers, are equal.F<
T if first arg is less than second arg.  Both must be numbers.F>
T if first arg is greater than second arg.  Both must be numbers.F<=
T if first arg is less than or equal to second arg.  Both must be numbers.F>=
T if first arg is greater than or equal to second arg.  Both must be numbers.F/=
T if first arg is not equal to second arg.  Both must be numbers.Fzerop
T if NUMBER is zero.Fint-to-string
Convert INT to a string by printing it in decimal, with minus sign if negative.Fstring-to-int
Convert STRING to an integer by parsing it as a decimal number.F+
Return sum of any number of numbers.F-
Negate number or subtract numbers.
With one arg, negates it.  With more than one arg,
subtracts all but the first from the first.F*
Returns product of any number of numbers.F/
Returns first argument divided by rest of arguments.F%
Returns remainder of first arg divided by second.Fmax
Return largest of all the arguments (which must be numbers.)Fmin
Return smallest of all the arguments (which must be numbers.)Flogand
Return bitwise and of all the arguments (numbers).Flogior
Return bitwise or of all the arguments (numbers).Flogxor
Return bitwise exclusive-or of all the arguments (numbers).Fash
Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
In this case, the sign bit is duplicated.Flsh
Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
In this case,  zeros are shifted in on the left.F1+
Return NUMBER plus one.F1-
Return NUMBER minus one.Flognot
Return the bitwise complement of ARG.Fdocumentation
Return the documentation string of FUNCTION.Fdocumentation-property
Return the documentation string that is SYMBOL's PROP property.
This differs from using `get' only in that it can refer to strings
stored in the etc/DOC file.FSnarf-documentation
Used during Emacs initialization, before dumping runnable Emacs,
to find pointers to doc strings stored in etc/DOC... and
record them in function definitions.
One arg, FILENAME, a string which does not include a directory.
The file is found in ../etc now; found in the exec-directory
when doc strings are referred to later in the dumped Emacs.Fsubstitute-command-keys
Return the STRING with substrings of the form \=\[COMMAND]
replaced by either:  a keystroke sequence that will invoke COMMAND,
or "M-x COMMAND" if COMMAND is not on any keys.
Substrings of the form \=\{MAPVAR} are replaced by summaries
(made by describe-bindings) of the value of MAPVAR, taken as a keymap.
Substrings of the form \=\<MAPVAR> specify to use the value of MAPVAR
as the keymap for future \=\[COMMAND] substrings.
\=\= quotes the following character and is discarded;
thus, \=\=\=\= puts \=\= into the output, and \=\=\=\[ puts \=\[ into the output.Fchar-to-string
Convert arg CHAR to a string containing that character.Fstring-to-char
Convert arg STRING to a character, the first character of that string.Fpoint
Return value of point, as an integer.
Beginning of buffer is position (point-min)Fpoint-marker
Return value of point, as a marker object.Fgoto-char
One arg, a number.  Set point to that number.
Beginning of buffer is position (point-min), end is (point-max).Fregion-beginning
Return position of beginning of region, as an integer.Fregion-end
Return position of end of region, as an integer.Fmark
Return this buffer's mark value as integer, or nil if no mark.
If you are using this in an editing command, you are most likely making
a mistake; see the documentation of `set-mark'.Fmark-marker
Return this buffer's mark, as a marker object.
Watch out!  Moving this marker changes the mark position.
The marker will not point anywhere if mark is not set.Fset-mark
Set this buffer's mark to POS.  Don't use this function!
That is to say, don't use this function unless you want
the user to see that the mark has moved, and you want the previous
mark position to be lost.

Normally, when a new mark is set, the old one should go on the stack.
This is why most applications should use push-mark, not set-mark.

Novice programmers often try to use the mark for the wrong purposes.
The mark saves a location for the user's convenience.
Most editing commands should not alter the mark.
To remember a location for internal use in the Lisp program,
store it in a Lisp variable.  Example:

   (let ((beg (point))) (forward-line 1) (delete-region beg (point))).Fsave-excursion
Save point (and mark), execute BODY, then restore point and mark.
Executes BODY just like PROGN.  Point and mark values are restored
even in case of abnormal exit (throw or error).Fbuffer-size
Return the number of characters in the current buffer.Fpoint-min
Return the minimum permissible value of point in the current buffer.
This is 1, unless a clipping restriction is in effect.Fpoint-min-marker
Return a marker to the beginning of the currently visible part of the buffer.
This is the beginning, unless a clipping restriction is in effect.Fpoint-max
Return the maximum permissible value of point in the current buffer.
This is (1+ (buffer-size)), unless a clipping restriction is in effect,
in which case it is less.Fpoint-max-marker
Return a marker to the end of the currently visible part of the buffer.
This is the actual end, unless a clipping restriction is in effect.Ffollowing-char
Return the character following point, as a number.Fpreceding-char
Return the character preceding point, as a number.Fbobp
Return T if point is at the beginning of the buffer.
If the buffer is narrowed, this means the beginning of the narrowed part.Feobp
Return T if point is at the end of the buffer.
If the buffer is narrowed, this means the end of the narrowed part.Fbolp
Return T if point is at the beginning of a line.Feolp
Return T if point is at the end of a line.
`End of a line' includes point being at the end of the buffer.Fchar-after
One arg, POS, a number.  Return the character in the current buffer
at position POS.
If POS is out of range, the value is NIL.Fuser-login-name
Return the name under which user logged in, as a string.
This is based on the effective uid, not the real uid.Fuser-real-login-name
Return the name of the user's real uid, as a string.
Differs from user-login-name when running under su.Fuser-uid
Return the effective uid of Emacs, as an integer.Fuser-real-uid
Return the real uid of Emacs, as an integer.Fuser-full-name
Return the full name of the user logged in, as a string.Fsystem-name
Return the name of the machine you are running on, as a string.Fcurrent-time-string
Return the current time, as a human-readable string.Finsert
Any number of args, strings or chars.  Insert them after point, moving point forward.Finsert-before-markers
Any number of args, strings or chars.  Insert them after point,
moving point forward.  Also, any markers pointing at the insertion point
get relocated to point after the newly inserted text.Finsert-char
Insert COUNT (second arg) copies of CHAR (first arg).
Both arguments are required.Fbuffer-substring
Return the contents of part of the current buffer as a string.
The two arguments specify the start and end, as character numbers.Fbuffer-string
Return the contents of the current buffer as a string.Finsert-buffer-substring
Insert before point a substring of the contents buffer BUFFER.
BUFFER may be a buffer or a buffer name.
Arguments START and END are character numbers specifying the substring.
They default to the beginning and the end of BUFFER.Fsubst-char-in-region
From START to END, replace FROMCHAR with TOCHAR each time it occurs.
If optional arg NOUNDO is non-nil, don't record this change for undo
and don't mark the buffer as really changed.Fdelete-region
Delete the text between point and mark.
When called from a program, expects two arguments,
character numbers specifying the stretch to be deleted.Fwiden
Remove restrictions from current buffer, allowing full text to be seen and edited.Fnarrow-to-region
Restrict editing in this buffer to the current region.
The rest of the text becomes temporarily invisible and untouchable
but is not deleted; if you save the buffer in a file, the invisible
text is included in the file.  \[widen] makes all visible again.

When calling from a program, pass two arguments; character numbers
bounding the text that should remain visible.Fsave-restriction
Execute the body, undoing at the end any changes to current buffer's restrictions.
Changes to restrictions are made by narrow-to-region or by widen.
Thus, the restrictions are the same after this function as they were before it.
The value returned is that returned by the last form in the body.

This function can be confused if, within the body, you widen
and then make changes outside the area within the saved restrictions.

Note: if you are using both save-excursion and save-restriction,
use save-excursion outermost.Fmessage
Print a one-line message at the bottom of the screen.
The first argument is a control string.
It may contain %s or %d or %c to print successive following arguments.
%s means print an argument as a string, %d means print as number in decimal,
%c means print a number as a single character.
The argument used by %s must be a string or a symbol;
the argument used by %d or %c must be a number.Fformat
Format a string out of a control-string and arguments.
The first argument is a control string.
It, and subsequent arguments substituted into it, become the value, which is a string.
It may contain %s or %d or %c to substitute successive following arguments.
%s means print an argument as a string, %d means print as number in decimal,
%c means print a number as a single character.
The argument used by %s must be a string or a symbol;
the argument used by %d, %b, %o, %x or %c must be a number.Fchar-equal
T if args (both characters (numbers)) match.  May ignore case.
Case is ignored if the current buffer specifies to do so.Fgetenv
One arg VAR, a string.  Return the value of environment variable VAR, as a string.Finteractive
Specify a way of parsing arguments for interactive use of a function.
For example, write
  (defun fun (arg) "Doc string" (interactive "p") ...use arg...)
to make arg be the prefix numeric argument when foo is called as a command.
This is actually a declaration rather than a function;
 it tells  call-interactively  how to read arguments
 to pass to the function.
When actually called,  interactive  just returns nil.

The argument of  interactive  is usually a string containing a code letter
 followed by a prompt.  (Some code letters do not use I/O to get
 the argument and do not need prompts.)  To prompt for multiple arguments,
 give a code letter, its prompt, a newline, and another code letter, etc.
If the argument is not a string, it is evaluated to get a list of
 arguments to pass to the function.
Just  (interactive)  means pass no args when calling interactively.

Code letters available are:
a -- Function name: symbol with a function definition.
b -- Name of existing buffer.
B -- Name of buffer, possibly nonexistent.
c -- Character.
C -- Command name: symbol with interactive function definition.
d -- Value of point as number.  Does not do I/O.
D -- Directory name.
f -- Existing file name.
F -- Possibly nonexistent file name.
k -- Key sequence (string).
m -- Value of mark as number.  Does not do I/O.
n -- Number read using minibuffer.
N -- Prefix arg converted to number, or if none, do like code `n'.
p -- Prefix arg converted to number.  Does not do I/O.
P -- Prefix arg in raw form.  Does not do I/O.
r -- Region: point and mark as 2 numeric args, smallest first.  Does no I/O.
s -- Any string.
S -- Any symbol.
v -- Variable name: symbol that is user-variable-p.
x -- Lisp expression read but not evaluated.
X -- Lisp expression read and evaluated.
In addition, if the first character of the string is '*' then an error is
 signaled if the buffer is read-only.
 This happens before reading any arguments.Fcall-interactively
Call FUNCTION, reading args according to its interactive calling specs.
The function contains a specification of how to do the argument reading.
In the case of user-defined functions, this is specified by placing a call
to the function `interactive' at the top level of the function body.
See `interactive'.

Optional second arg RECORD-FLAG non-nil
means unconditionally put this command in the command-history.
Otherwise, this is done only if an arg is read using the minibuffer.Fprefix-numeric-value
Return numeric meaning of raw prefix argument ARG.
A raw prefix argument is what you get from (interactive "P").Vprefix-arg
The value of the prefix argument for the next editing command.
It may be a number, or the symbol - for just a minus sign as arg,
or a list whose car is a number for just one or more C-U's
or nil if no argument has been specified.

You cannot examine this variable to find the argument for this command
since it has been set to nil by the time you can look.
Instead, you should use the variable current-prefix-arg, although
normally commands can get this prefix argument with (interactive "P").Vcurrent-prefix-arg
The value of the prefix argument for this editing command.
It may be a number, or the symbol - for just a minus sign as arg,
or a list whose car is a number for just one or more C-U's
or nil if no argument has been specified.
This is what (interactive "P") returns.Vcommand-history
List of recent commands that read arguments from terminal.
Each command is represented as a form to evaluate.For
Eval args until one of them yields non-NIL, then return that value.
The remaining args are not evalled at all.
If all args return NIL, return NIL.Fand
Eval args until one of them yields NIL, then return NIL.
The remaining args are not evalled at all.
If no arg yields NIL, return the last arg's value.Fif
(if C T E...) if C yields non-NIL do T, else do E...
Returns the value of T or the value of the last of the E's.
There may be no E's; then if C yields NIL, the value is NIL.Fcond
(cond CLAUSES...) tries each clause until one succeeds.
Each clause looks like (C BODY...).  C is evaluated
and, if the value is non-nil, this clause succeeds:
then the expressions in BODY are evaluated and the last one's
value is the value of the cond expression.
If a clause looks like (C), C's value if non-nil is returned from cond.
If no clause succeeds, cond returns nil.Fprogn
Eval arguments in sequence, and return the value of the last one.Fprog1
Eval arguments in sequence, then return the FIRST arg's value.
This value is saved during the evaluation of the remaining args,
whose values are discarded.Fprog2
Eval arguments in sequence, then return the SECOND arg's value.
This value is saved during the evaluation of the remaining args,
whose values are discarded.Fsetq
(setq SYM VAL SYM VAL ...) sets each SYM to the value of its VAL.
The SYMs are not evaluated.  Thus (setq x y) sets x to the value of y.
Each SYM is set before the next VAL is computed.Fquote
Return the argument, without evaluating it.  (quote x)  yields  x.Ffunction
Quote a function object.
Equivalent to the quote function in the interpreter,
but causes the compiler to compile the argument as a function
if it is not a symbol.Finteractive-p
Return t if function in which this appears was called interactively.
This means that the function was called with call-interactively (which
includes being called as the binding of a key)
and input is currently coming from the keyboard (not in keyboard macro).Fdefun
(defun NAME ARGLIST [DOCSTRING] BODY...) defines NAME as a function.
The definition is (lambda ARGLIST [DOCSTRING] BODY...).
See also the function  interactive .Fdefmacro
(defmacro NAME ARGLIST [DOCSTRING] BODY...) defines NAME as a macro.
The definition is (macro lambda ARGLIST [DOCSTRING] BODY...).
When the macro is called, as in (NAME ARGS...),
the function (lambda ARGLIST BODY...) is applied to
the list ARGS... as it appears in the expression,
and the result should be a form to be evaluated instead of the original.Fdefvar
(defvar SYMBOL INITVALUE DOCSTRING) defines SYMBOL as an advertised variable.
INITVALUE is evaluated, and used to set SYMBOL, only if SYMBOL's value is void.
INITVALUE and DOCSTRING are optional.
If DOCSTRING starts with *, this variable is identified as a user option.
 This means that M-x set-variable and M-x edit-options recognize it.
If INITVALUE is missing, SYMBOL's value is not set.Fdefconst
(defconst SYMBOL INITVALUE DOCSTRING) defines SYMBOL as a constant variable.
The intent is that programs do not change this value (but users may).
Always sets the value of SYMBOL to the result of evalling INITVALUE.
DOCSTRING is optional.
If DOCSTRING starts with *, this variable is identified as a user option.
 This means that M-x set-variable and M-x edit-options recognize it.Fuser-variable-p
Returns t if VARIABLE is intended to be set and modified by users,
as opposed to by programs.
Determined by whether the first character of the documentation
for the variable is "*"Flet*
(let* VARLIST BODY...) binds variables according to VARLIST then executes BODY.
The value of the last form in BODY is returned.
Each element of VARLIST is a symbol (which is bound to NIL)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
Each VALUEFORM can refer to the symbols already bound by this VARLIST.Flet
(let VARLIST BODY...) binds variables according to VARLIST then executes BODY.
The value of the last form in BODY is returned.
Each element of VARLIST is a symbol (which is bound to NIL)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
All the VALUEFORMs are evalled before any symbols are bound.Fwhile
(while TEST BODY...) if TEST yields non-NIL, execute the BODY forms and repeat.Fmacroexpand
If FORM is a macro call, expand it.
If the result of expansion is another macro call, expand it, etc.
Return the ultimate expansion.
The second optional arg ENVIRONMENT species an environment of macro
definitions to shadow the loaded ones for use in file byte-compilation.Fcatch
(catch TAG BODY...) perform BODY allowing nonlocal exits using (throw TAG).
TAG is evalled to get the tag to use.  throw  to that tag exits this catch.
Then the BODY is executed.  If no  throw  happens, the value of the last BODY
form is returned from  catch.  If a  throw  happens, it specifies the value to
return from  catch.Fthrow
(throw TAG VALUE): throw to the catch for TAG and return VALUE from it.
Both TAG and VALUE are evalled.Funwind-protect
Do BODYFORM, protecting with UNWINDFORMS.
Usage looks like (unwind-protect BODYFORM UNWINDFORMS...)
If BODYFORM completes normally, its value is returned
after executing the UNWINDFORMS.
If BODYFORM exits nonlocally, the UNWINDFORMS are executed anyway.Fcondition-case
Regain control when an error is signaled.
 (condition-case VAR BODYFORM HANDLERS...)
executes BODYFORM and returns its value if no error happens.
Each element of HANDLERS looks like (CONDITION-NAME BODY...)
where the BODY is made of Lisp expressions.
The handler is applicable to an error
if CONDITION-NAME is one of the error's condition names.
When a handler handles an error,
control returns to the condition-case and the handler BODY... is executed
with VAR bound to (SIGNALED-CONDITIONS . SIGNAL-DATA).
The value of the last BODY form is returned from the condition-case.
See SIGNAL for more info.Fsignal
Signal an error.  Args are SIGNAL-NAME, and associated DATA.
A signal name is a symbol with an  error-conditions  property
that is a list of condition names.
A handler for any of those names will get to handle this signal.
The symbol  error  should always be one of them.

DATA should be a list.  Its elements are printed as part of the error message.
If the signal is handled, DATA is made available to the handler.
See  condition-case.Fcommandp
T if FUNCTION makes provisions for interactive calling.
This means it contains a description for how to read arguments to give it.
The value is nil for an invalid function or a symbol with no function definition.

Interactively callable functions include strings (treated as keyboard macros),
lambda-expressions that contain a top-level call to  interactive ,
autoload definitions made by  autoload  with non-nil fourth argument,
and some of the built-in functions of Lisp.

Also, a symbol is commandp if its function definition is commandp.Fautoload
Define FUNCTION to autoload from FILE.
FUNCTION is a symbol; FILE is a file name string to pass to  load.
Third arg DOCSTRING is documentation for the function.
Fourth arg FROM_KBD if non-nil says function can be called interactively.
Fifth arg MACRO if non-nil says the function is really a macro.
Third through fifth args give info about the real definition.
They default to nil.
If FUNCTION is already defined other than as an autoload,
this does nothing and returns nil.Feval
Evaluate FORM and return its value.Fapply
Call FUNCTION, passing remaining arguments to it.  The last argument
is a list of arguments to pass.
Thus, (apply '+ 1 2 '(3 4)) returns 10.Ffuncall
Call first argument as a function, passing remaining arguments to it.
Thus,  (funcall 'cons 'x 'y)  returns  (x . y).Fbacktrace-debug
Set the debug-on-exit flag of eval frame LEVEL levels down to FLAG.
The debugger is entered when that frame exits, if the flag is non-nil.Fbacktrace
Print a trace of Lisp function calls currently active.
Output stream used is value of standard-output.Vmax-specpdl-size
Limit on number of Lisp variable bindings & unwind-protects before error.Vmax-lisp-eval-depth
Limit on depth in eval, apply and funcall before error.Vquit-flag
Non-nil causes  eval  to abort, unless  inhibit-quit  is non-nil.
Typing C-G sets  quit-flag  non-nil, regardless of  inhibit-quit.Vinhibit-quit
Non-nil inhibits C-g quitting from happening immediately.
Note that  quit-flag  will still be set by typing C-g,
so a quit will be signalled as soon as  inhibit-quit  is nil.
To prevent this happening, set  quit-flag  to nil
before making  inhibit-quit  nil.Vstack-trace-on-error
*Non-nil means automatically display a backtrace buffer
after any error that is handled by the editor command loop.Vdebug-on-error
*Non-nil means enter debugger if an error is signaled.
Does not apply to errors handled by condition-case.
See also variable debug-on-quit.Vdebug-on-quit
*Non-nil means enter debugger if quit is signaled (C-G, for example).
Does not apply if quit is handled by a condition-case.Vdebug-on-next-call
Non-nil means enter debugger before next eval, apply or funcall.Vdebugger
Function to call to invoke debugger.
If due to frame exit, args are 'exit and value being returned;
 this function's value will be returned instead of that.
If due to error, args are 'error and list of signal's args.
If due to apply or funcall entry, one arg, 'lambda.
If due to eval entry, one arg, 't.Vmocklisp-arguments
While in a mocklisp function, the list of its unevaluated args.Fidentity
Return the argument unchanged.Frandom
Return a pseudo-random number.
On most systems all integers representable in Lisp are equally likely.
  This is 24 bits' worth.
On some systems, absolute value of result never exceeds 2 to the 14.
If optional argument is supplied as  t,
 the random number seed is set based on the current time and pid.Flength
Return the length of vector, list or string SEQUENCE.Fstring-equal
T if two strings have identical contents.
Symbols are also allowed; their print names are used instead.Fstring-lessp
T if first arg string is less than second in lexicographic order.
Symbols are also allowed; their print names are used instead.Fappend
Concatenate arguments and make the result a list.
The result is a list whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.Fconcat
Concatenate arguments and make the result a string.
The result is a string whose elements are the elements of all the arguments.
Each argument may be a string, a list of numbers, or a vector of numbers.Fvconcat
Concatenate arguments and make the result a vector.
The result is a vector whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.Fcopy-sequence
Return a copy of a list, vector or string.Fcopy-alist
Return a copy of ALIST.
This is a new alist which represents the same mapping
from objects to objects, but does not share the alist structure with ALIST.
The objects mapped (cars and cdrs of elements of the alist)
are shared, however.Fsubstring
Return a substring of STRING, starting at index FROM and ending before TO.
TO may be nil or omitted; then the substring runs to the end of STRING.
If FROM or TO is negative, it counts from the end.Fnthcdr
Takes cdr N times on LIST, returns the result.Fnth
Returns the Nth element of LIST.
N counts from zero.  If LIST is not that long, nil is returned.Felt
Returns element of SEQUENCE at index N.Fmemq
Returns non-nil if ELT is an element of LIST.  Comparison done with EQ.
The value is actually the tail of LIST whose car is ELT.Fassq
Returns non-nil if ELT is the car of an element of LIST.  Comparison done with eq.
The value is actually the element of LIST whose car is ELT.Fassoc
Returns non-nil if ELT is the car of an element of LIST.  Comparison done with  equal.
The value is actually the element of LIST whose car is ELT.Frassq
Returns non-nil if ELT is the cdr of an element of LIST.  Comparison done with EQ.
The value is actually the element of LIST whose cdr is ELT.Fdelq
Deletes by side effect any occurrences of ELT as a member of LIST.
The modified LIST is returned.
If the first member of LIST is ELT, there is no way to remove it by side effect;
therefore, write  (setq foo (delq element foo))  to be sure of changing  foo.Fnreverse
Reverses LIST by modifying cdr pointers.  Returns the beginning of the reversed list.Freverse
Reverses LIST, copying.  Returns the beginning of the reversed list.
See also the function  nreverse, which is used more often.Fsort
Sort LIST, stably, comparing elements using PREDICATE.
Returns the sorted list.  LIST is modified by side effects.
PREDICATE is called with two elements of LIST, and should return T
if the first element is "less" than the second.Fget
Return the value of SYMBOL's PROPNAME property.
This is the last VALUE stored with  (put SYMBOL PROPNAME VALUE).Fput
Store SYMBOL's PROPNAME property with value VALUE.
It can be retrieved with  (get SYMBOL PROPNAME).Fequal
T if two Lisp objects have similar structure and contents.
They must have the same data type.
Conses are compared by comparing the cars and the cdrs.
Vectors and strings are compared element by element.
Numbers are compared by value.  Symbols must match exactly.Ffillarray
Store each element of ARRAY with ITEM.  ARRAY is a vector or string.Fnconc
Concatenate any number of lists by altering them.
Only the last argument is not altered, and need not be a list.Fmapconcat
Apply FN to each element of SEQ, and concat the results as strings.
In between each pair of results, stick in SEP.
Thus, " " as SEP results in spaces between the values return by FN.Fmapcar
Apply FUNCTION to each element of LIST, and make a list of the results.
The result is a list just as long as LIST.Fy-or-n-p
Ask user a "y or n" question.  Return t if answer is "y".
No confirmation of the answer is requested; a single character is enough.
Also accepts Space to mean yes, or Delete to mean no.Fyes-or-no-p
Ask user a yes or no question.  Return t if answer is yes.
The user must confirm the answer with a newline, and can rub it out if not confirmed.Fload-average
Return the current 1 minute, 5 minute and 15 minute load averages
in a list (all floating point load average values are multiplied by 100
and then turned into integers).Ffeaturep
Returns t if FEATURE is present in this Emacs.
Use this to conditionalize execution of lisp code based on the presence or
absence of emacs or environment extensions.
Use  provide  to declare that a feature is available.
This function looks at the value of the variable  features.Fprovide
Announce that FEATURE is a feature of the current Emacs.Frequire
If FEATURE is not present in Emacs (ie (featurep FEATURE) is false),
load FILENAME.  FILENAME is optional and defaults to FEATURE.Vfeatures
A list of symbols which are the features of the executing emacs.
Used by  featurep  and  require, and altered by  provide.Fwrite-char
Output character CHAR to stream STREAM.
STREAM defaults to the value of `standard-output' (which see).Fwith-output-to-temp-buffer
Binding `standard-output' to buffer named BUFNAME, execute BODY then display that buffer.
The buffer is cleared out initially, and marked as unmodified when done.
All output done by BODY is inserted in that buffer by default.
It is displayed in another window, but not selected.
The value of the last form in BODY is returned.
If variable `temp-buffer-show-hook' is non-nil, call it at the end
to get the buffer displayed.  It gets one argument, the buffer to display.Fterpri
Output a newline to STREAM (or value of standard-output).Fprin1
Output the printed representation of OBJECT, any Lisp object.
Quoting characters are printed when needed to make output that `read'
can handle, whenever this is possible.
Output stream is STREAM, or value of `standard-output' (which see).Fprin1-to-string
Return a string containing the printed representation of OBJECT,
any Lisp object.  Quoting characters are used when needed to make output
that `read' can handle, whenever this is possible.Fprinc
Output the printed representation of OBJECT, any Lisp object.
No quoting characters are used; no delimiters are printed around
the contents of strings.
Output stream is STREAM, or value of standard-output (which see).Fprint
Output the printed representation of OBJECT, with newlines around it.
Quoting characters are printed when needed to make output that `read'
can handle, whenever this is possible.
Output stream is STREAM, or value of `standard-output' (which see).Vstandard-output
Function print uses by default for outputting a character.
This may be any function of one argument.
It may also be a buffer (output is inserted before point)
or a marker (output is inserted and the marker is advanced)
or the symbol t (output appears in the minibuffer line).Vprint-length
Maximum length of list to print before abbreviating.`nil' means no limit.Vprint-escape-newlines
Non-nil means print newlines in strings as backslash-n.Fread-char
Read a character from the command input (keyboard or macro).
It is returned as a number.Fget-file-char
Don't use this yourself.Fload
Execute a file of Lisp code named FILE.
First tries FILE with .elc appended, then tries with .el,
 then tries FILE unmodified.  Searches directories in  load-path.
If optional second arg NOERROR is non-nil,
 report no error if FILE doesn't exist.
Print messages at start and end of loading unless
 optional third arg NOMESSAGE is non-nil.
If optional fourth arg NOSUFFIX is non-nil, don't try adding
 suffixes .elc or .el to the specified name FILE.
Return t if file exists.Feval-current-buffer
Execute the current buffer as Lisp code.
Programs can pass argument PRINTFLAG which controls printing of output:
nil means discard it; anything else is stream for print.Feval-region
Execute the region as Lisp code.
When called from programs, expects two arguments,
giving starting and ending indices in the current buffer
of the text to be executed.
Programs can pass third argument PRINTFLAG which controls printing of output:
nil means discard it; anything else is stream for print.Fread
Read one Lisp expression as text from STREAM, return as Lisp object.
If STREAM is nil, use the value of standard-input (which see).
STREAM or standard-input may be:
 a buffer (read from point and advance it)
 a marker (read from where it points and advance it)
 a function (call it with no arguments for each character)
 a string (takes text from string, starting at the beginning)
 t (read text line using minibuffer and use it).Fread-from-string
Read one Lisp expression which is represented as text by STRING.
Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).
START and END optionally delimit a substring of STRING from which to read;
 they default to 0 and (length STRING) respectively.Fintern
Return the symbol whose name is STRING.
A second optional argument specifies the obarray to use;
it defaults to the value of  obarray.Fintern-soft
Return the symbol whose name is STRING, or nil if none exists yet.
A second optional argument specifies the obarray to use;
it defaults to the value of  obarray.Fmapatoms
Call FUNCTION on every symbol in OBARRAY.
OBARRAY defaults to the value of  obarray.Vobarray
Symbol table for use by  intern  and  read.
It is a vector whose length ought to be prime for best results.
Each element is a list of all interned symbols whose names hash in that bucket.Vvalues
List of values of all expressions which were read, evaluated and printed.
Order is reverse chronological.Vstandard-input
Stream for read to get input from.
See documentation of read for possible values.Vload-path
*List of directories to search for files to load.
Each element is a string (directory name) or nil (try default directory).
Initialized based on EMACSLOADPATH environment variable, if any,
otherwise to default specified in by file paths.h when emacs was built.Vload-in-progress
Non-nil iff inside of  load.Fmake-abbrev-table
Create a new, empty abbrev table object.Fclear-abbrev-table
Undefine all abbrevs in abbrev table TABLE, leaving it empty.Fdefine-abbrev
Define an abbrev in TABLE named NAME, to expand to EXPANSION or call HOOK.
NAME and EXPANSION are strings.  HOOK is a function or nil.
To undefine an abbrev, define it with EXPANSION = nilFdefine-global-abbrev
Define ABBREV as a global abbreviation for EXPANSION.Fdefine-mode-abbrev
Define ABBREV as a mode-specific abbreviation for EXPANSION.Fabbrev-symbol
Return the symbol representing abbrev named ABBREV.
Value is nil if that abbrev is not defined.
Optional second arg TABLE is abbrev table to look it up in.
Default is try buffer's mode-specific abbrev table, then global table.Fabbrev-expansion
Return the string that ABBREV expands into in the current buffer.
Optionally specify an abbrev table; then ABBREV is looked up in that table only.Fexpand-abbrev
Expand the abbrev before point, if it is an abbrev.
Effective when explicitly called even when abbrev-mode is not enabled.
Returns t if expansion took place.Funexpand-abbrev
Undo the expansion of the last abbrev that expanded.Finsert-abbrev-table-description
Insert before point a description of abbrev table named NAME.
NAME is a symbol whose value is an abbrev table.
If 2nd arg READABLE is non-nil, a readable description is inserted.
Otherwise description is an expression,
a call to define-abbrev-table which would
define NAME exactly as it is currently defined.Fdefine-abbrev-table
Define TABNAME (a symbol) as an abbrev table name.
Define abbrevs in it according to DEFINITIONS, a list of elements
of the form (ABBREVNAME EXPANSION HOOK USECOUNT).Vabbrev-table-name-list
List of symbols whose values are  abbrev tables.Vglobal-abbrev-table
The abbrev table whose abbrevs affect all buffers.
Each buffer may also have a local abbrev table.
If it does, the local table overrides the global one
for any particular abbrev defined in both.Vfundamental-mode-abbrev-table
The abbrev table of mode-specific abbrevs for Fundamental Mode.Vlast-abbrev
The abbrev-symbol of the last abbrev expanded.Vlast-abbrev-text
The exact text of the last abbrev expanded.
nil if the abbrev has already been unexpanded.Vlast-abbrev-location
The location of the last abbrev expanded.Vabbrev-start-location
Buffer position for expand-abbrev to use as the start of the abbrev.
nil means use the word before point as the abbrev.
Set to nil each time expand-abbrev is called.Vabbrev-start-location-buffer
Buffer that abbrev-start-location has been set for.
Trying to expand an abbrev in any other buffer clears abbrev-start-location.Vlocal-abbrev-table
Local (mode-specific) abbrev table of current buffer.Vabbrevs-changed
Set non-nil by defining or altering any word abbrevs.Vabbrev-all-caps
*Set non-nil means expand multi-word abbrevs all caps if abbrev was so.Fsyntax-table-p
Return t if ARG is a syntax table.
Any vector of 256 elements will do.Fsyntax-table
Return the current syntax table.
This is the one specified by the current buffer.Fstandard-syntax-table
Return the standard syntax table.
This is the one used for new buffers.Fcopy-syntax-table
Construct a new syntax table and return it.
It is a copy of the TABLE, which defaults to the standard syntax table.Fset-syntax-table
Select a new syntax table for the current buffer.
One argument, a syntax table.Fchar-syntax
Return the syntax code of CHAR, described by a character.
For example, if CHAR is a word constituent, ?w is returned.
The characters that correspond to various syntax codes
are listed in the documentation of  modify-syntax-entry.Fmodify-syntax-entry
Set syntax for character CHAR according to string S.
The syntax is changed only for table TABLE, which defaults to
 the current buffer's syntax table.
The first character of S should be one of the following:
  Space    whitespace syntax.    w   word constituent.
  _        symbol constituent.   .   punctuation.
  (        open-parenthesis.     )   close-parenthesis.
  "        string quote.         \   character-quote.
  $        paired delimiter.     '   expression prefix operator.
  <       comment starter.     >   comment ender.
Only single-character comment start and end sequences are represented thus.
Two-character sequences are represented as described below.
The second character of S is the matching parenthesis,
 used only if the first character is ( or ).
Any additional characters are flags.
Defined flags are the characters 1, 2, 3 and 4.
 1 means C is the start of a two-char comment start sequence.
 2 means C is the second character of such a sequence.
 3 means C is the start of a two-char comment end sequence.
 4 means C is the second character of such a sequence.Fdescribe-syntax
Describe the syntax specifications in the syntax table.
The descriptions are inserted in a buffer, which is selected so you can see it.Fforward-word
Move point forward ARG words (backward if ARG is negative).
Normally returns t.
If an edge of the buffer is reached, point is left there
and nil is returned.Fscan-lists
Scan from character number FROM by COUNT lists.
Returns the character number of the position thus found.

If DEPTH is nonzero, paren depth begins counting from that value,
only places where the depth in parentheses becomes zero
are candidates for stopping; COUNT such places are counted.
Thus, a positive value for DEPTH means go out levels.

Comments are ignored if parse-sexp-ignore-comments is non-nil.

If the beginning or end of (the visible part of) the buffer is reached
and the depth is wrong, an error is signaled.
If the depth is right but the count is not used up, nil is returned.Fscan-sexps
Scan from character number FROM by COUNT balanced expressions.
Returns the character number of the position thus found.

Comments are ignored if parse-sexp-ignore-comments is non-nil.

If the beginning or end of (the visible part of) the buffer is reached
in the middle of a parenthetical grouping, an error is signaled.
If the beginning or end is reached between groupings but before count is used up,
nil is returned.Fbackward-prefix-chars
Move point backward over any number of chars with syntax "prefix".Fparse-partial-sexp
Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
Parsing stops at TO or when certain criteria are met;
 point is set to where parsing stops.
If fifth arg STATE is omitted or nil,
 parsing assumes that FROM is the beginning of a function.
Value is a list of seven elements describing final state of parsing:
 1. depth in parens.
 2. character address of start of innermost containing list; nil if none.
 3. character address of start of last complete sexp terminated.
 4. non-nil if inside a string.
    (it is the character that will terminate the string.)
 5. t if inside a comment.
 6. t if following a quote character.
 7. the minimum paren-depth encountered during this scan.
If third arg TARGETDEPTH is non-nil, parsing stops if the depth
in parentheses becomes equal to TARGETDEPTH.
Fourth arg STOPBEFORE non-nil means stop when come to
 any character that starts a sexp.
Fifth arg STATE is a seven-list like what this function returns.
It is used to initialize the state of the parse.Vparse-sexp-ignore-comments
Non-nil means forward-sexp, etc., should treat comments as whitespace.
Non-nil works only when the comment terminator is something like */,
and appears only when it ends a comment.
If comments are terminated by newlines,
you must make this variable nil.Fml-if
if  for mocklisp programsFml-nargs
# arguments to this mocklisp functionFml-arg
Argument #N to this mocklisp function.Fml-interactive
True if this mocklisp function was called interactively.Fml-provide-prefix-argument
Evaluate second argument, using first argument as prefix arg value.Fml-prefix-argument-loop
Fml-substr
Return a substring of STRING, starting at index FROM and of length LENGTH.
If either FROM or LENGTH is negative, the length of STRING is added to it.Finsert-string
Mocklisp-compatibility insert function.
Like the function `insert' except that any argument that is a number
is converted into a string by expressing it in decimal.Fbyte-code
Fcall-process
Call PROGRAM in separate process.
Program's input comes from file INFILE (nil means /dev/null).
Insert output in BUFFER before point; t means current buffer;
 nil for BUFFER means discard it; 0 means discard and don't wait.
Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining arguments are strings passed as command arguments to PROGRAM.
This function waits for PROGRAM to terminate;
if you quit, the process is killed.Fcall-process-region
Send text from START to END to a process running PROGRAM.
Delete the text if DELETE is non-nil.
Put output in BUFFER, before point.  nil => discard it, t => current buffer.
Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining args are passed to PROGRAM at startup as command args.
This function normally waits for the process to terminate;
if you quit, the process is killed.Vshell-file-name
*File name to load inferior shells from.
Initialized from the SHELL environment variable.Vexec-path
*List of directories to search programs to run in subprocesses.
Each element is a string (directory name) or nil (try default directory).Vexec-directory
Directory that holds programs that come with GNU Emacs,
intended for Emacs to invoke.Vprocess-environment
List of strings to append to environment of subprocesses that are started.
Each string should have the format ENVVARNAME=VALUE.Fgetenv
Return the value of environment variable VAR, as a string.
When invoked interactively, print the value in the echo area.
VAR is a string, the name of the variable,
 or the symbol t, meaning to return an alist representing the
 current environment.Fsetenv
Return the value of environment variable VAR, as a string.
When invoked interactively, print the value in the echo area.
VAR is a string, the name of the variable.Fopen-line
Insert a newline and leave point before it.
With arg, inserts that many newlines.Fsplit-line
Split current line, moving portion beyond point vertically down.Fquoted-insert
Read next input character and insert it.
Useful for inserting control characters.
You may also type up to 3 octal digits, to insert a character with that codeFdelete-indentation
Join this line to previous and fix up whitespace at join.
With argument, join this line to following line.Ffixup-whitespace
Fixup white space between objects around point.
Leave one space or none, according to the context.Fdelete-horizontal-space
Delete all spaces and tabs around point.Fjust-one-space
Delete all spaces and tabs around point, leaving one space.Fdelete-blank-lines
On blank line, delete all surrounding blank lines, leaving just one.
On isolated blank line, delete that one.
On nonblank line, delete all blank lines that follow it.Fback-to-indentation
Move point to the first non-whitespace character on this line.Fnewline-and-indent
Insert a newline, then indent according to major mode.
Indentation is done using the current indent-line-function.
In programming language modes, this is the same as TAB.
In some text modes, where TAB inserts a tab, this indents to the
specified left-margin column.Freindent-then-newline-and-indent
Reindent current line, insert newline, then indent the new line.
Indentation of both lines is done according to the current major mode,
which means that the current value of indent-line-function is called.
In programming language modes, this is the same as TAB.
In some text modes, where TAB inserts a tab, this indents to the
specified left-margin column.Fbackward-delete-char-untabify
Delete characters backward, changing tabs into spaces.
Delete ARG chars, and kill (save in kill ring) if KILLP is non-nil.
Interactively, ARG is the prefix arg (default 1)
and KILLP is t if prefix arg is was specified.Fzap-to-char
Kill up to (but not including) ARG'th occurrence of CHAR.
Goes backward if ARG is negative; goes to end of buffer if CHAR not found.Fbeginning-of-buffer
Move point to the beginning of the buffer; leave mark at previous position.
With arg N, put point N/10 of the way from the true beginning.
Don't use this in Lisp programs!
(goto-char (point-min)) is faster and does not set the mark.Fend-of-buffer
Move point to the end of the buffer; leave mark at previous position.
With arg N, put point N/10 of the way from the true end.
Don't use this in Lisp programs!
(goto-char (point-max)) is faster and does not set the mark.Fmark-whole-buffer
Put point at beginning and mark at end of buffer.Fcount-lines-region
Print number of lines in the region.Fwhat-line
Print the current line number (in the buffer) of point.Fcount-lines
Return number of newlines between START and END.Fwhat-cursor-position
Print info on cursor position (on screen and within buffer).Ffundamental-mode
Major mode not specialized for anything in particular.
Other major modes are defined by comparison with this one.Feval-expression
Evaluate EXPRESSION and print value in minibuffer.
Value is also consed on to front of variable  values  's value.Fedit-and-eval-command
Prompting with PROMPT, let user edit COMMAND and eval result.
COMMAND is a Lisp expression.  Let user edit that expression in
the minibuffer, then read and evaluate the result.Frepeat-complex-command
Edit and re-evaluate last complex command, or ARGth from last.
A complex command is one which used the minibuffer.
The command is placed in the minibuffer as a Lisp form for editing.
The result is executed, repeating the command as changed.
If the command has been changed or is not the most recent previous command
it is added to the front of the command history.
Whilst editing the command, the following commands are available:
\{repeat-complex-command-map}Fnext-complex-command
Inserts the next element of `command-history' into the minibuffer.Fprevious-complex-command
Inserts the previous element of `command-history' into the minibuffer.Fgoto-line
Goto line ARG, counting from line 1 at beginning of buffer.Fundo
Undo some previous changes.
Repeat this command to undo more changes.
A numeric argument serves as a repeat count.Fshell-command
Execute string COMMAND in inferior shell; display output, if any.
Optional second arg non-nil (prefix arg, if interactive)
means insert output in current buffer after point (leave mark after it).Fshell-command-on-region
Execute string COMMAND in inferior shell with region as input.
Normally display output (if any) in temp buffer;
Prefix arg means replace the region with it.
Noninteractive args are START, END, COMMAND, FLAG.
Noninteractively FLAG means insert output in place of text from START to END,
and put point at the end, but don't alter the mark.Funiversal-argument
Begin a numeric argument for the following command.
Digits or minus sign following this command make up the numeric argument.
If no digits or minus sign follow, this command by itself provides 4 as argument.
Used more than once, this command multiplies the argument by 4 each time.Fdigit-argument
Part of the numeric argument for the next command.Fnegative-argument
Begin a negative numeric argument for the next command.Fforward-to-indentation
Move forward ARG lines and position at first nonblank character.Fbackward-to-indentation
Move backward ARG lines and position at first nonblank character.Vkill-lines-magic
*if non-nil a kill-line at the beginning of a line kills the entire line,
including the newline at the endFkill-line
Kill the rest of the current line; if no nonblanks there, kill thru newline.
With prefix argument, kill that many lines from point.
Negative arguments kill lines backward.

When calling from a program, nil means "no arg",
a number counts as a prefix arg.Vkill-ring
List of killed text sequences.Vkill-ring-max
*Maximum length of kill ring before oldest elements are thrown away.Vkill-ring-yank-pointer
The tail of the kill ring whose car is the last thing yanked.Fkill-region
Kill between point and mark.
The text is deleted but saved in the kill ring.
The command \[yank] can retrieve it from there.
(If you want to kill and then yank immediately, use \[copy-region-as-kill].)

This is the primitive for programs to kill text (as opposed to deleting it).
Supply two arguments, character numbers indicating the stretch of text
 to be killed.
Any command that calls this function is a "kill command".
If the previous command was also a kill command,
the text killed this time appends to the text killed last time
to make one entry in the kill ring.Fcopy-region-as-kill
Save the region as if killed, but don't kill it.Fappend-next-kill
Cause following command, if kill, to append to previous kill.Frotate-yank-pointer
Rotate the yanking point in the kill ring.Fyank-pop
Replace just-yanked stretch of killed-text with a different stretch.
This command is allowed only immediately after a  yank  or a  yank-pop.
At such a time, the region contains a stretch of reinserted
previously-killed text.  yank-pop  deletes that text and inserts in its
place a different stretch of killed text.

With no argument, the previous kill is inserted.
With argument n, the n'th previous kill is inserted.
If n is negative, this is a more recent kill.

The sequence of kills wraps around, so that after the oldest one
comes the newest one.Fyank
Reinsert the last stretch of killed text.
More precisely, reinsert the stretch of killed text most recently
killed OR yanked.
With just C-U as argument, same but put point in front (and mark at end).
With argument n, reinsert the nth most recently killed stretch of killed
text.
See also the command \[yank-pop].Finsert-buffer
Insert after point the contents of BUFFER.
Puts mark after the inserted text.
BUFFER may be a buffer or a buffer name.Fappend-to-buffer
Append to specified buffer the text of the region.
It is inserted into that buffer before its point.

When calling from a program, give three arguments:
a buffer or the name of one, and two character numbers
specifying the portion of the current buffer to be copied.Fprepend-to-buffer
Prepend to specified buffer the text of the region.
It is inserted into that buffer after its point.

When calling from a program, give three arguments:
a buffer or the name of one, and two character numbers
specifying the portion of the current buffer to be copied.Fcopy-to-buffer
Copy to specified buffer the text of the region.
It is inserted into that buffer, replacing existing text there.

When calling from a program, give three arguments:
a buffer or the name of one, and two character numbers
specifying the portion of the current buffer to be copied.Fmark
Return this buffer's mark value as integer, or nil if no mark.
If you are using this in an editing command, you are most likely making
a mistake; see the documentation of `set-mark'.Fset-mark
Set this buffer's mark to POS.  Don't use this function!
That is to say, don't use this function unless you want
the user to see that the mark has moved, and you want the previous
mark position to be lost.

Normally, when a new mark is set, the old one should go on the stack.
This is why most applications should use push-mark, not set-mark.

Novice emacs-lisp programmers often try to use the mark for the wrong
purposes.  The mark saves a location for the user's convenience.
Most editing commands should not alter the mark.
To remember a location for internal use in the Lisp program,
store it in a Lisp variable.  Example:

   (let ((beg (point))) (forward-line 1) (delete-region beg (point))).Vmark-ring
The list of saved former marks of the current buffer,
most recent first.Vmark-ring-max
*Maximum size of mark ring.  Start discarding off end if gets this big.Fset-mark-command
Set mark at where point is, or jump to mark.
With no prefix argument, set mark, and push previous mark on mark ring.
With argument, jump to mark, and pop into mark off the mark ring.

Novice emacs-lisp programmers often try to use the mark for the wrong
purposes.  See the documentation of `set-mark' for more information.Fpush-mark
Set mark at LOCATION (point, by default) and push old mark on mark ring.
Displays "Mark set" unless the optional second arg NOMSG is non-nil.

Novice emacs-lisp programmers often try to use the mark for the wrong
purposes.  See the documentation of `set-mark' for more information.Fpop-mark
Pop off mark ring into the buffer's actual mark.
Does not set point.  Does nothing if mark ring is empty.Fexchange-point-and-mark
Put the mark where point is now, and point where the mark is now.Fnext-line
Move cursor vertically down ARG lines.
If there is no character in the target line exactly under the current column,
the cursor is positioned after the character in that line which spans this
column, or at the end of the line if it is not long enough.
If there is no line in the buffer after this one,
a newline character is inserted to create a line
and the cursor moves to that line.

The command \[set-goal-column] can be used to create
a semipermanent goal column to which this command always moves.
Then it does not try to move vertically.

If you are thinking of using this in a Lisp program, consider
using `forward-line' instead.  It is usually easier to use
and more reliable (no dependence on goal column, etc.).Fprevious-line
Move cursor vertically up ARG lines.
If there is no character in the target line exactly over the current column,
the cursor is positioned after the character in that line which spans this
column, or at the end of the line if it is not long enough.

The command \[set-goal-column] can be used to create
a semipermanent goal column to which this command always moves.
Then it does not try to move vertically.

If you are thinking of using this in a Lisp program, consider using
`forward-line' with negative argument instead..  It is usually easier
to use and more reliable (no dependence on goal column, etc.).Vtrack-eol
*Non-nil means vertical motion starting at the end of a line should keep to ends of lines.
This means moving to the end of each line moved onto.Vgoal-column
*Semipermanent goal column for vertical motion, as set by \[set-goal-column], or nil.Vtemporary-goal-column
Current goal column for vertical motion.
It is the column where point was at the start of current run of vertical motion commands.Fset-goal-column
Set the current horizontal position as a goal for \[next-line] and \[previous-line].
Those commands will move to this position in the line moved to
rather than trying to keep the same horizontal position.
With a non-nil argument, clears out the goal column
so that \[next-line] and \[previous-line] resume vertical motion.Ftranspose-chars
Interchange characters around point, moving forward one character.
With prefix arg ARG, effect is to take character before point
and drag it forward past ARG other characters (backward if ARG negative).
If no argument and at end of line, the previous two chars are exchanged.Ftranspose-words
Interchange words around point, leaving point at end of them.
With prefix arg ARG, effect is to take word before or around point
and drag it forward past ARG other words (backward if ARG negative).
If ARG is zero, the words around or after point and around or after mark
are interchanged.Ftranspose-sexps
Like \[transpose-words] but applies to sexps.
Does not work on a sexp that point is in the middle of
if it is a list or string.Ftranspose-lines
Exchange current line and previous line, leaving point after both.
With argument ARG, takes previous line and moves it past ARG lines.
With argument 0, interchanges line point is in with line mark is in.Vcomment-column
*Column to indent right-margin comments to.
Setting this variable automatically makes it local to the current buffer.Vcomment-start
*String to insert to start a new comment, or nil if no comment syntax defined.Vcomment-start-skip
*Regexp to match the start of a comment plus everything up to its body.
If there are any \(...\) pairs, the comment delimiter text is held to begin
at the place matched by the close of the first pair.Vcomment-end
*String to insert to end a new comment.
Should be an empty string if comments are terminated by end-of-line.Vcomment-indent-hook
Function to compute desired indentation for a comment
given the character number it starts at.Findent-for-comment
Indent this line's comment to comment column, or insert an empty comment.Fset-comment-column
Set the comment column based on point.
With no arg, set the comment column to the current column.
With just minus as arg, kill any comment on this line.
With any other arg, set comment column to indentation of the previous comment
 and then align or create a comment on this line at that column.Fkill-comment
Kill the comment on this line, if any.
With argument, kill comments on that many lines starting with this one.Fbackward-word
Move backward until encountering the end of a word.
With argument, do this that many times.
In programs, it is faster to call forward-word with negative arg.Fmark-word
Set mark arg words away from point.Fkill-word
Kill characters forward until encountering the end of a word.
With argument, do this that many times.Fbackward-kill-word
Kill characters backward until encountering the end of a word.
With argument, do this that many times.Vfill-prefix
*String for filling to insert at front of new line, or nil for none.
Setting this variable automatically makes it local to the current buffer.Vcomment-multi-line
*Non-nil means \[indent-new-comment-line] should continue same comment
on new line, with no new terminator or starter.Findent-new-comment-line
Break line at point and indent, continuing comment if presently within one.
The body of the continued comment is indented under the previous comment line.Fauto-fill-mode
Toggle auto-fill mode.
With arg, turn auto-fill mode on iff arg is positive.
In auto-fill mode, inserting a space at a column beyond  fill-column
automatically breaks the line at a previous space.Fturn-on-auto-fill
Unconditionally turn on Auto Fill mode.Fset-fill-column
Set fill-column to current column, or to argument if given.
fill-column's value is separate for each buffer.Fset-selective-display
Set selective-display to ARG; clear it if no arg.
When selective-display is a number > 0,
lines whose indentation is >= selective-display are not displayed.
selective-display's value is separate for each buffer.Foverwrite-mode
Toggle overwrite mode.
With arg, turn overwrite mode on iff arg is positive.
In overwrite mode, printing characters typed in replace existing text
on a one-for-one basis, rather than pushing it to the right.Vblink-matching-paren
*Non-nil means show matching open-paren when close-paren is inserted.Vblink-matching-paren-distance
*If non-nil, is maximum distance to search for matching open-paren
when close-paren is inserted.Fblink-matching-open
Move cursor momentarily to the beginning of the sexp before point.Fkeyboard-quit
Signal a  quit  condition.Fset-variable
Set VARIABLE to VALUE.  VALUE is a Lisp object.
When using this interactively, supply a Lisp expression for VALUE.
If you want VALUE to be a string, you must surround it with doublequotes.Vmode-specific-map
Keymap for characters following C-c.Vhelp-map
Keymap for characters following the Help key.Fhelp-with-tutorial
Select the Emacs learn-by-doing tutorial.Fdescribe-key-briefly
Print the name of the function KEY invokes.  KEY is a string.Fprint-help-return-message
Display or return message saying how to restore windows after help command.
Computes a message and applies the argument FUNCTION to it.
If FUNCTION is nil, applies `message' to it, thus printing it.Fdescribe-key
Display documentation of the function KEY invokes.  KEY is a string.Fdescribe-mode
Display documentation of current major mode.Fdescribe-distribution
Display info on how to obtain the latest version of GNU Emacs.Fdescribe-copying
Display info on how you may redistribute copies of GNU Emacs.Fdescribe-no-warranty
Display info on all the kinds of warranty Emacs does NOT have.Fview-emacs-news
Display info on recent changes to Emacs.Fview-lossage
Display last 100 input keystrokes.Fhelp-for-help
You have typed C-h, the help character.  Type a Help option:

A  command-apropos.   Give a substring, and see a list of commands
              (functions interactively callable) that contain
          that substring.  See also the  apropos  command.
B  describe-bindings.  Display table of all key bindings.
C  describe-key-briefly.  Type a command key sequence;
          it prints the function name that sequence runs.
F  describe-function.  Type a function name and get documentation of it.
I  info. The  info  documentation reader.
K  describe-key.  Type a command key sequence;
          it displays the full documentation.
L  view-lossage.  Shows last 100 characters you typed.
M  describe-mode.  Print documentation of current major mode,
          which describes the commands peculiar to it.
N  view-emacs-news.  Shows emacs news file.
S  describe-syntax.  Display contents of syntax table, plus explanations
T  help-with-tutorial.  Select the Emacs learn-by-doing tutorial.
V  describe-variable.  Type name of a variable;
          it displays the variable's documentation and value.
W  where-is.  Type command name; it prints which keystrokes
          invoke that command.
C-c print Emacs copying permission (General Public License).
C-d print Emacs ordering information.
C-n print news of recent Emacs changes.
C-w print information on absence of warranty for GNU Emacs.Fdescribe-function
Display the full documentation of FUNCTION (a symbol).Fdescribe-variable
Display the full documentation of VARIABLE (a symbol).Fcommand-apropos
Like apropos but lists only symbols that are names of commands
(interactively callable functions).Vdelete-auto-save-files
*Non-nil means delete a buffer's auto-save file
when the buffer is saved for real.Vmake-backup-files
*Create a backup of each file when it is saved for the first time.
This can be done by renaming the file or by copying.

Renaming means that Emacs renames the existing file so that it is a
backup file, then writes the buffer into a new file.  Any other names
that the old file had will now refer to the backup file.
The new file is owned by you and its group is defaulted.

Copying means that Emacs copies the existing file into the backup file,
then writes the buffer on top of the existing file.  Any other names
that the old file had will now refer to the new (edited) file.
The file's owner and group are unchanged.

The choice of renaming or copying is controlled by the variables
backup-by-copying, backup-by-copying-when-linked and
backup-by-copying-when-mismatch.Vbackup-by-copying
*Non-nil means always use copying to create backup files.
See documentation of variable  make-backup-files.Vbackup-by-copying-when-linked
*Non-nil means use copying to create backups for files with multiple names.
This causes the alternate names to refer to the latest version as edited.
This variable is relevant only if  backup-by-copying  is nil.Vbackup-by-copying-when-mismatch
*Non-nil means create backups by copying if this preserves owner or group.
Renaming may still be used (subject to control of other variables)
when it would not result in changing the owner or group of the file;
that is, for files which are owned by you and whose group matches
the default for a new file created there by you.
This variable is relevant only if  backup-by-copying  is nil.Vbuffer-offer-save
*Non-nil in a buffer means offer to save the buffer on exit
even if the buffer is not visiting a file.  Automatically local in
all buffers.Vfile-precious-flag
*Non-nil means protect against I/O errors while saving files.
Some modes set this non-nil in particular buffers.Vversion-control
*Control use of version numbers for backup files.
t means make numeric backup versions unconditionally.
nil means make them for files that have some already.
never means do not make them.Vdired-kept-versions
*When cleaning directory, number of versions to keep.Vtrim-versions-without-asking
*If true, deletes excess backup versions silently.
Otherwise asks confirmation.Vkept-old-versions
*Number of oldest versions to keep when a new numbered backup is made.Vkept-new-versions
*Number of newest versions to keep when a new numbered backup is made.
Includes the new backup.  Must be > 0Vrequire-final-newline
*t says silently put a newline at the end whenever a file is saved.
Non-nil but not t says ask user whether to add a newline in each such case.
nil means don't add newlines.Vauto-save-default
*t says by default do auto-saving of every file-visiting buffer.Vauto-save-visited-file-name
*t says auto-save a buffer in the file it is visiting, when practical.
Normally auto-save files are written under other names.Vsave-abbrevs
*Non-nil means save word abbrevs too when files are saved.
Loading an abbrev file sets this to t.Vfind-file-run-dired
*Non-nil says run dired if find-file is given the name of a directory.Vfind-file-not-found-hooks
List of functions to be called for find-file on nonexistent file.
These functions are called as soon as the error is detected.
buffer-file-name is already set up.
The functions are called in the order given,
until one of them returns non-nil.Vfind-file-hooks
List of functions to be called after a buffer is loaded from a file.
The buffer's local variables (if any) will have been processed before the
functions are called.Vwrite-file-hooks
List of functions to be called before writing out a buffer to a file.
If one of them returns non-nil, the file is considered already written
and the rest are not called.Vinhibit-local-variables
*Non-nil means query before obeying a file's local-variables list.
This applies when the local-variables list is scanned automatically
after you find a file.  If you explicitly request such a scan with
\[normal-mode], there is no query, regardless of this variable.Fpwd
Show the current default directory.Fcd
Make DIR become the current buffer's default directory.Fload-file
Load the file FILE of Lisp code.Fload-library
Load the library named LIBRARY.
This is an interface to the function `load'.Fswitch-to-buffer-other-window
Select buffer BUFFER in another window.Ffind-file
Edit file FILENAME.
Switch to a buffer visiting file FILENAME,
creating one if none already exists.Ffind-file-other-window
Edit file FILENAME, in another window.
May create a new window, or reuse an existing one;
see the function display-buffer.Ffind-file-read-only
Edit file FILENAME but don't save without confirmation.
Like find-file but marks buffer as read-only.Ffind-alternate-file
Find file FILENAME, select its buffer, kill previous buffer.
If the current buffer now contains an empty file that you just visited
(presumably by mistake), use this command to visit the file you really want.Fcreate-file-buffer
Create a suitably named buffer for visiting FILENAME, and return it.
FILENAME (sans directory) is used unchanged if that name is free;
otherwise a string <2> or <3> or ... is appended to get an unused name.Ffind-file-noselect
Read file FILENAME into a buffer and return the buffer.
If a buffer exists visiting FILENAME, return that one,
but verify that the file has not changed since visited or saved.
The buffer is not selected, just returned to the caller.Fafter-find-file
Called after finding a file and by the default revert function.
Sets buffer mode, parses local variables.
Optional args ERROR and WARN: ERROR non-nil means there was an
error in reading the file.  WARN non-nil means warn if there
exists an auto-save file more recent than the visited file.
Finishes by calling the functions in find-file-hooks.Fnormal-mode
Choose the major mode for this buffer automatically.
Also sets up any specified local variables of the file.
Uses the visited file name, the -*- line, and the local variables spec.

This function is called automatically from `find-file'.  In that case,
if `inhibit-local-variables' is non-`nil' we require confirmation before
processing a local variables spec.  If you run `normal-mode' explicitly,
confirmation is never required.Fset-auto-mode
Select major mode appropriate for current buffer.
May base decision on visited file name (See variable  auto-mode-list)
or on buffer contents (-*- line or local variables spec), but does not look
for the "mode:" local variable.  For that, use  hack-local-variables.Fhack-local-variables
Parse, and bind or evaluate as appropriate, any local variables
for current buffer.Fset-visited-file-name
Change name of file visited in current buffer to FILENAME.
The next time the buffer is saved it will go in the newly specified file.
nil or empty string as argument means make buffer not be visiting any file.
Remember to delete the initial contents of the minibuffer
if you wish to pass an empty string as the argument.Fwrite-file
Write current buffer into file FILENAME.
Makes buffer visit that file, and marks it not modified.Fbackup-buffer
Make a backup of the disk file visited by the current buffer, if appropriate.
This is normally done before saving the buffer the first time.
If the value is non-nil, it is the result of `file-modes' on the original file;
this means that the caller, after saving the buffer, should change the modes
of the new file to agree with the old modes.Ffile-name-sans-versions
Return FILENAME sans backup versions or strings.
This is a separate procedure so your site-init or startup file can
redefine it.Fmake-backup-file-name
Create the non-numeric backup file name for FILE.
This is a separate function so you can redefine it for customization.Fbackup-file-name-p
Return non-nil if FILE is a backup file name (numeric or not).
This is a separate function so you can redefine it for customization.
You may need to redefine file-name-sans-versions as well.Ffind-backup-file-name
Find a file name for a backup file, and suggestions for deletions.
Value is a list whose car is the name for the backup file
 and whose cdr is a list of old versions to consider deleting now.Ffile-nlinks
Return number of names file FILENAME has.Fsave-buffer
Save current buffer in visited file if modified.  Versions described below.

By default, makes the previous version into a backup file
 if previously requested or if this is the first save.
With 1 or 3 \[universal-argument]'s, marks this version
 to become a backup when the next save is done.
With 2 or 3 \[universal-argument]'s,
 unconditionally makes the previous version into a backup file.
With argument of 0, never makes the previous version into a backup file.

If a file's name is FOO, the names of its numbered backup versions are
 FOO.~i~ for various integers i.  A non-numbered backup file is called FOO~.
Numeric backups (rather than FOO~) will be made if value of
 `version-control' is not the atom `never' and either there are already
 numeric versions of the file being backed up, or `version-control' is
 non-nil.
We don't want excessive versions piling up, so there are variables
 `kept-old-versions', which tells Emacs how many oldest versions to keep,
 and `kept-new-versions', which tells how many newest versions to keep.
 Defaults are 2 old versions and 2 new.
`dired-kept-versions' controls dired's clean-directory (.) command.
If `trim-versions-without-asking' is nil, system will query user
 before trimming versions.  Otherwise it does it silently.Fdelete-auto-save-file-if-necessary
Delete the auto-save filename for the current buffer (if it has one)
if variable  delete-auto-save-files  is non-nil.Fbasic-save-buffer
Save the current buffer in its visited file, if it has been modified.Fsave-some-buffers
Save some modified file-visiting buffers.  Asks user about each one.
With argument, saves all with no questions.Fnot-modified
Mark current buffer as unmodified, not needing to be saved.Ftoggle-read-only
Change whether this buffer is visiting its file read-only.Finsert-file
Insert contents of file FILENAME into buffer after point.
Set mark after the inserted text.Fappend-to-file
Append the contents of the region to the end of file FILENAME.
When called from a function, expects three arguments,
START, END and FILENAME.  START and END are buffer positions
saying what text to write.Vrevert-buffer-function
Function to use to revert this buffer, or nil to do the default.Frevert-buffer
Replace the buffer text with the text of the visited file on disk.
This undoes all changes since the file was visited or saved.
If latest auto-save file is more recent than the visited file,
asks user whether to use that instead.
First argument (optional) non-nil means don't offer to use auto-save file.
 This is the prefix arg when called interactively.

Second argument (optional) non-nil means don't ask for confirmation at all.

If revert-buffer-function's value is non-nil, it is called to do the work.Frecover-file
Visit file FILE, but get contents from its last auto-save file.Fkill-some-buffers
For each buffer, ask whether to kill it.Fauto-save-mode
Toggle auto-saving of contents of current buffer.
With arg, turn auto-saving on if arg is positive, else off.Frename-auto-save-file
Adjust current buffer's auto save file name for current conditions.
Also rename any existing auto save file.Fmake-auto-save-file-name
Return file name to use for auto-saves of current buffer.
Does not consider auto-save-visited-file-name; that is checked
before calling this function.
You can redefine this for customization.
See also auto-save-file-name-p.Fauto-save-file-name-p
Return non-nil if FILENAME can be yielded by make-auto-save-file-name.
FILENAME should lack slashes.
You can redefine this for customization.Vlist-directory-brief-switches
*Switches for list-directory to pass to `ls' for brief listing,Vlist-directory-verbose-switches
*Switches for list-directory to pass to `ls' for verbose listing,Flist-directory
Display a list of files in or matching DIRNAME, a la `ls'.
DIRNAME is globbed by the shell if necessary.
Prefix arg (second arg if noninteractive) means supply -l switch to `ls'.
Actions controlled by variables list-directory-brief-switches
 and list-directory-verbose-switches.Fsave-buffers-kill-emacs
Offer to save each buffer, then kill this Emacs fork.
With prefix arg, silently save all file-visiting buffers, then kill.Vctl-x-4-map
Keymap for subcommands of C-x 4Fsplit-window-vertically
Split current window into two windows, one above the other.
This window becomes the uppermost of the two, and gets
ARG lines.  No arg means split equally.Fsplit-window-horizontally
Split current window into two windows side by side.
This window becomes the leftmost of the two, and gets
ARG columns.  No arg means split equally.Fenlarge-window-horizontally
Make current window ARG columns wider.Fshrink-window-horizontally
Make current window ARG columns narrower.Findent-according-to-mode
Indent line in proper way for current major mode.Findent-for-tab-command
Indent line in proper way for current major mode.Findent-rigidly
Indent all lines starting in the region sideways by ARG columns.
Called from a program, takes three arguments, START, END and ARG.Vindent-region-function
Function which is short cut to indent each line in region with Tab.
nil means really call Tab on each line.Findent-region
Indent each nonblank line in the region.
With no argument, indent each line with Tab.
With argument COLUMN, indent each line to that column.
Called from a program, takes three args: START, END and COLUMN.Findent-relative-maybe
Indent a new line like previous nonblank line.Findent-relative
Space out to under next indent point in previous nonblank line.
An indent point is a non-whitespace character following whitespace.
If the previous nonblank line has no indent points beyond
the column point starts at,  tab-to-tab-stop  is done instead.Vtab-stop-list
*List of tab stop positions used by tab-to-tab-stops.Vedit-tab-stops-map
Keymap used in edit-tab-stops.Vedit-tab-stops-buffer
Buffer whose tab stops are being edited--in case
the variable tab-stop-list is local in that buffer.Fedit-tab-stops
Edit the tab stops used by tab-to-tab-stop.
Creates a buffer *Tab Stops* containing text describing the tab stops.
A colon indicates a column where there is a tab stop.
You can add or remove colons and then do C-c C-c to make changes take effect.Fedit-tab-stops-note-changes
Put edited tab stops into effect.Ftab-to-tab-stop
Insert spaces or tabs to next defined tab-stop column.
The variable tab-stop-list is a list of columns at which there are tab stops.
Use \[edit-tab-stops] to edit them interactively.Vmode-line-buffer-identification
Mode-line control for identifying the buffer being displayed.
Its default value is "Emacs: %17b".  Major modes that edit things
other than ordinary files may change this (e.g. Info, Dired,...)Vmode-line-process
Mode-line control for displaying info on process status.
Normally nil in most modes, since there is no process to display.Vmode-line-modified
Mode-line control for displaying whether current buffer is modified.Vminor-mode-alist
Alist saying how to show minor modes in the mode line.
Each element looks like (VARIABLE STRING);
STRING is included in the mode line iff VARIABLE's value is non-nil.Vfunction-keymap
Keymap containing definitions of keypad and function keys.Vparagraph-start
*Regexp for beginning of a line that starts OR separates paragraphs.Vparagraph-separate
*Regexp for beginning of a line that separates paragraphs.
If you change this, you may have to change paragraph-start also.Vsentence-end
*Regexp describing the end of a sentence.
All paragraph boundaries also end sentences, regardless.Vpage-delimiter
*Regexp describing line-beginnings that separate pages.Vcase-replace
*Non-nil means query-replace should preserve case in replacements.Vindent-line-function
Function to indent current line.Vonly-global-abbrevs
*t means user plans to use global abbrevs only.
Makes the commands to define mode-specific abbrevs define global ones instead.Vcompile-command
*Last shell command used to do a compilation; default for next compilation.Vdired-listing-switches
*Switches passed to ls for Dired.  MUST contain the `l' option.
MUST NOT contain the `F, `s' or `i'' option.Vlpr-switches
*List of strings to pass as extra switch args to lpr when it is invoked.Vtags-file-name
*File name of tag table.
To switch to a new tag table, setting this variable is sufficient.
Use the `etags' program to make a tag table file.Vshell-prompt-pattern
*Regexp used by Newline command in shell mode to match subshell prompts.
Anything from beginning of line up to the end of what this pattern matches
is deemed to be prompt, and is not reexecuted.Vledit-save-files
*Non-nil means Ledit should save files before transferring to Lisp.Vledit-go-to-lisp-string
*Shell commands to execute to resume Lisp job.Vledit-go-to-liszt-string
*Shell commands to execute to resume Lisp compiler job.Vdisplay-time-day-and-date
*Non-nil means M-x display-time should display day and date as well as time.Vauto-mode-alist
Alist of filename patterns vs corresponding major mode functions.
Each element looks like (REGEXP . FUNCTION).
Visiting a file whose name matches REGEXP causes FUNCTION to be called.Vctl-x-4-map
Keymap for subcommands of C-x 4Fadd-change-log-entry
Find change log file and add an entry for today.
First arg (interactive prefix) non-nil means prompt for user name and site.
Second arg is file name of change log.
Optional third arg OTHER-WINDOW non-nil means visit in other window.Fadd-change-log-entry-other-window
Find change log file in other window, and add an entry for today.F`
(` FORM) Expands to a form that will generate FORM.
FORM is `almost quoted' -- see backquote.el for a description.Fbyte-compile-file
Compile a file of Lisp code named FILENAME into a file of byte code.
The output file's name is made by appending "c" to the end of FILENAME.Fbyte-recompile-directory
Recompile every .el file in DIRECTORY that needs recompilation.
This is if a .elc file exists but is older than the .el file.
If the .elc file does not exist, offer to compile the .el file
only if a prefix argument has been specified.Fbatch-byte-compile
Runs byte-compile-file on the files remaining on the command line.
Must be used only with -batch, and kills emacs on completion.
Each file will be processed even if an error occurred previously.
For example, invoke "emacs -batch -f batch-byte-compile $emacs/ ~/*.el"Fcalendar
Display three-month calendar in another window.
The three months appear side by side, with the current month in the middle
surrounded by the previous and next months.  The cursor is put on today's date.

An optional prefix argument ARG causes the calendar displayed to be
ARG months in the future if ARG is positive or in the past if ARG is
negative; in this case the cursor goes on the first day of the month.

The Gregorian calendar is assumed.

After preparing the calendar window, the hooks calendar-hook are run
when the calendar is for the current month--that is, the was no prefix
argument.  If the calendar is for a future or past month--that is, there
was a prefix argument--the hooks offset-calendar-hook are run.  Thus, for
example, setting calendar-hooks to 'star-date will cause today's date to be
replaced by asterisks to highlight it in the window.Flist-command-history
List history of commands typed to minibuffer.
The number of commands listed is controlled by  list-command-history-max.
Calls value of  list-command-history-filter  (if non-nil) on each history
element to judge if that element should be excluded from the list.

The buffer is left in Command History mode.Fcommand-history-mode
Major mode for examining commands from  command-history.
The number of commands listed is controlled by  list-command-history-max.
The command history is filtered by  list-command-history-filter  if non-nil.

Like Emacs-Lisp Mode except that characters do not insert themselves and
Digits provide prefix arguments.  Tab does not indent.
\{command-history-map}
Calls the value of  command-history-hook  if that is non-nil
The Command History listing is recomputed each time this mode is
invoked.Frepeat-matching-complex-command
Edit and re-evaluate complex command with name matching PATTERN.
Matching occurrences are displayed, most recent first, until you
select a form for evaluation.  If PATTERN is empty (or nil), every form
in the command history is offered.  The form is placed in the minibuffer
for editing and the result is evaluated.Fcompare-windows
Compare text in current window with text in next window.
Compares the text starting at point in each window,
moving over text in each one as far as they match.Fcompile
Compile the program including the current buffer.  Default: run `make'.
Runs COMMAND, a shell command, in a separate process asynchronously
with output going to the buffer *compilation*.
You can then use the command \[next-error] to find the next error message
and move to the source code that caused it.Fgrep
Run grep, with user-specified args, and collect output in a buffer.
While grep runs asynchronously, you can use the \[next-error] command
to find the text that grep hits refer to.Fnext-error
Visit next compilation error message and corresponding source code.
This operates on the output from the \[compile] command.
If all preparsed error messages have been processed,
the error message buffer is checked for new ones.
A non-nil argument (prefix arg, if interactive)
means reparse the error message buffer and start at the first error.Fdabbrev-expand
Expand previous word "dynamically".
Expands to the most recent, preceding word for which this is a prefix.
If no suitable preceding word is found, words following point are considered.

A positive prefix argument, N, says to take the Nth backward DISTINCT
possibility.  A negative argument says search forward.  The variable
dabbrev-backward-only may be used to limit the direction of search to
backward if set non-nil.

If the cursor has not moved from the end of the previous expansion and
no argument is given, replace the previously-made expansion
with the next possible expansion not yet tried.Fdebug
Enter debugger.  Returns if user says "continue".
Arguments are mainly for use when this is called
 from the internals of the evaluator.
You may call with no args, or you may
 pass nil as the first arg and any other args you like.
 In that case, the list of args after the first will
 be printed into the backtrace buffer.Fcancel-debug-on-entry
Undoes effect of debug-on-entry on FUNCTION.Fdebug-on-entry
Request FUNCTION to invoke debugger each time it is called.
If the user continues, FUNCTION's execution proceeds.
Works by modifying the definition of FUNCTION,
which must be written in Lisp, not predefined.
Use `cancel-debug-on-entry' to cancel the effect of this command.
Redefining FUNCTION also does that.Fdired
"Edit" directory DIRNAME--delete, rename, print, etc. some files in it.
Dired displays a list of files in DIRNAME.
You can move around in it with the usual commands.
You can flag files for deletion with C-d
and then delete them by typing `x'.
Type `h' after entering dired for more info.Fdired-other-window
"Edit" directory DIRNAME.  Like \[dired] but selects in another window.Fdired-noselect
Like M-x dired but returns the dired buffer as value, does not select it.Fdissociated-press
Dissociate the text of the current buffer.
Output goes in buffer named *Dissociation*,
which is redisplayed each time text is added to it.
Every so often the user must say whether to continue.
If ARG is positive, require ARG chars of continuity.
If ARG is negative, require -ARG words of continuity.
Default is 2.Fdoctor
Switch to *doctor* buffer and start giving psychotherapy.Fdisassemble
Print disassembled code for OBJECT on (optional) STREAM.
OBJECT can be a function name, lambda expression or any function object
returned by SYMBOL-FUNCTION.  If OBJECT is not already compiled, we will
compile it (but not redefine it).Felectric-buffer-list
Vaguely like ITS lunar select buffer;
combining typeoutoid buffer listing with menuoid buffer selection.

This pops up a buffer describing the set of emacs buffers.
If the very next character typed is a space then the buffer list
 window disappears.

Otherwise, one may move around in the buffer list window, marking
 buffers to be selected, saved or deleted.

To exit and select a new buffer, type Space when the cursor is on the
 appropriate line of the buffer-list window.

Other commands are much like those of buffer-menu-mode.

Calls value of  electric-buffer-menu-mode-hook  on entry if non-nil.

\{electric-buffer-menu-mode-map}Felectric-command-history
Major mode for examining and redoing commands from  command-history.
The number of command listed is controlled by  list-command-history-max.
The command history is filtered by  list-command-history-filter  if non-nil.
Combines typeout Command History list window with menu like selection
of an expression from the history for re-evaluation in the *original* buffer.

The history displayed is filtered by  list-command-history-filter  if non-nil.

This pops up a window with the Command History listing.  If the very
next character typed is Space, the listing is killed and the previous
window configuration is restored.  Otherwise, you can browse in the
Command History with  Return  moving down and  Delete  moving up, possibly
selecting an expression to be redone with Space or quitting with `Q'.

Like Emacs-Lisp Mode except that characters do not insert themselves and
Tab and linefeed do not indent.  Instead these commands are provided:
Space or !    edit then evaluate current line in history inside
           the ORIGINAL buffer which invoked this mode.
           The previous window configuration is restored
           unless the invoked command changes it.
C-c C-c, C-], Q    Quit and restore previous window configuration.
LFD, RET    Move to the next line in the history.
DEL        Move to the previous line in the history.
?        Provides a complete list of commands.

Calls the value of  electric-command-history-hook  if that is non-nil
The Command History listing is recomputed each time this mode is invoked.Fedt-emulation-on
Begin emulating DEC's EDT editor.
Certain keys are rebound; including nearly all keypad keys.
Use \[edt-emulation-off] to undo all rebindings except the keypad keys.
Note that this function does not work if called directly from the .emacs file.
Instead, the .emacs file should do (setq term-setup-hook 'edt-emulation-on)
Then this function will be called at the time when it will work.Ffortran-mode
Major mode for editing fortran code.
Tab indents the current fortran line correctly.
`do' statements must not share a common `continue'.

Type `;?' or `;\[help-command]' to display a list of built-in abbrevs for Fortran keywords.

Variables controlling indentation style and extra features:

 comment-start
    Normally nil in Fortran mode.  If you want to use comments
    starting with `!', set this to the string "!".
 fortran-do-indent
    Extra indentation within do blocks.  (default 3)
 fortran-if-indent
    Extra indentation within if blocks.  (default 3)
 fortran-continuation-indent
    Extra indentation appled to continuation statements.  (default 5)
 fortran-comment-line-column
    Amount of indentation for text within full-line comments. (default 6)
 fortran-comment-indent-style
    nil    means don't change indentation of text in full-line comments,
    fixed  means indent that text at column fortran-comment-line-column
    relative  means indent at fortran-comment-line-column beyond the
           indentation for a line of code.
    Default value is fixed.
 fortran-comment-indent-char
    Character to be inserted instead of space for full-line comment
    indentation.  (default is a space)
 fortran-minimum-statement-indent
    Minimum indentation for fortran statements. (default 6)
 fortran-line-number-indent
    Maximum indentation for line numbers.  A line number will get
    less than this much indentation if necessary to avoid reaching
    column 5.  (default 1)
 fortran-check-all-num-for-matching-do
    Non-nil causes all numbered lines to be treated as possible 'continue'
    statements.  (default nil)
 fortran-continuation-char
    character to be inserted in column 5 of a continuation line.
    (default $)
 fortran-comment-region
    String inserted by \[fortran-comment-region] at start of each line in
    region.  (default "c$$$")
 fortran-electric-line-number
    Non-nil causes line number digits to be moved to the correct column
    as typed.  (default t)
 fortran-startup-message
    Set to nil to inhibit message first time fortran-mode is used.

Turning on Fortran mode calls the value of the variable fortran-mode-hook
with no args, if that value is non-nil.
\{fortran-mode-map}Fftp-find-file
FTP to HOST to get FILE, logging in as USER with password PASSWORD.
Interactively, HOST and FILE are specified by reading a string with
 a colon character separating the host from the filename.
USER and PASSWORD are defaulted from the values used when
 last ftping from HOST (unless password-remembering is disabled).
 Supply a password of the symbol `t' to override this default
 (interactively, this is done by giving a prefix arg)Fftp-write-file
FTP to HOST to write FILE, logging in as USER with password PASSWORD.
Interactively, HOST and FILE are specified by reading a string with colon
separating the host from the filename.
USER and PASSWORD are defaulted from the values used when
 last ftping from HOST (unless password-remembering is disabled).
 Supply a password of the symbol `t' to override this default
 (interactively, this is done by giving a prefix arg)Fgdb
Run gdb on program FILE in buffer *gdb-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for GDB.  If you wish to change this, use
the GDB commands `cd DIR' and `directory'.Fset-gosmacs-bindings
Rebind some keys globally to make GNU Emacs resemble Gosling Emacs.
Use \[set-gnu-bindings] to restore previous global bindings.Fhanoi
Towers of Hanoi diversion.  Argument is number of rings.FHelper-help
Provide help for current mode.FHelper-describe-bindings
Describe local key bindings of current mode.Finfo
Enter Info, the documentation browser.FInfo-tagify
Create or update Info-file tag table in current buffer.FInfo-validate
Check current buffer for validity as an Info file.
Check that every node pointer points to an existing node.FInfo-split
Split an info file into an indirect file plus bounded-size subfiles.
Each subfile will be up to 50000 characters plus one node.

To use this command, first visit a large Info file that has a tag table.
The buffer is modified into a (small) indirect info file
which should be saved in place of the original visited file.

The subfiles are written in the same directory the original file is in,
with names generated by appending `-' and a number to the original file name.

The indirect file still functions as an Info file, but it contains
just the tag table and a directory of subfiles.Fbatch-info-validate
Runs  Info-validate  on the files remaining on the command line.
Must be used only with -batch, and kills emacs on completion.
Each file will be processed even if an error occurred previously.
For example, invoke "emacs -batch -f batch-info-validate $info/ ~/*.info"Fledit-mode
Major mode for editing text and stuffing it to a Lisp job.
Like Lisp mode, plus these special commands:
  M-C-d    -- record defun at or after point
       for later transmission to Lisp job.
  M-C-r -- record region for later transmission to Lisp job.
  C-x z -- transfer to Lisp job and transmit saved text.
  M-C-c -- transfer to Liszt (Lisp compiler) job
       and transmit saved text.
\{ledit-mode-map}
To make Lisp mode automatically change to Ledit mode,
do (setq lisp-mode-hook 'ledit-from-lisp-mode)Flpr-buffer
Print buffer contents as with Unix command `lpr'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.Fprint-buffer
Print buffer contents as with Unix command `lpr -p'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.Flpr-region
Print region contents as with Unix command `lpr'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.Fprint-region
Print region contents as with Unix command `lpr -p'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.Finsert-kbd-macro
Insert in buffer the definition of kbd macro NAME, as Lisp code.
Second argument KEYS non-nil means also record the keys it is on.
 (This is the prefix argument, when calling interactively.)

This Lisp code will, when executed, define the kbd macro with the
same definition it has now.  If you say to record the keys,
the Lisp code will also rebind those keys to the macro.
Only global key bindings are recorded since executing this Lisp code
always makes global bindings.

To save a kbd macro, visit a file of Lisp code such as your ~/.emacs,
use this command, and then save the file.Fkbd-macro-query
Query user during kbd macro execution.
With prefix argument, enters recursive edit,
 reading keyboard commands even within a kbd macro.
 You can give different commands each time the macro executes.
Without prefix argument, reads a character.  Your options are:
 Space -- execute the rest of the macro.
 DEL -- skip the rest of the macro; start next repetition.
 C-d -- skip rest of the macro and don't repeat it any more.
 C-r -- enter a recursive edit, then on exit ask again for a character
 C-l -- redisplay screen and ask again.Fname-last-kbd-macro
Assign a name to the last keyboard macro defined.
One arg, a symbol, which is the name to define.
The symbol's function definition becomes the keyboard macro string.
Such a "function" cannot be called from Lisp, but it is a valid command
definition for the editor command loop.Fmake-command-summary
Make a summary of current key bindings in the buffer *Summary*.
Previous contents of that buffer are killed first.Fdefine-mail-alias
Define NAME as a mail-alias that translates to DEFINITION.Fmanual-entry
Display the Unix manual entry for TOPIC.
TOPIC is either the title of the entry, or has the form TITLE(SECTION)
where SECTION is the desired section of the manual, as in `tty(4)'.Fmh-rmail
Inc(orporate) new mail (no arg) or scan a MH mail box (arg given).
This front end uses the MH mail system, which uses different conventions
from the usual mail system.Fmh-smail
Send mail using the MH mail system.Fconvert-mocklisp-buffer
Convert buffer of Mocklisp code to real Lisp that GNU Emacs can run.Fmodula-2-mode
This is a mode intended to support program development in Modula-2.
All control constructs of Modula-2 can be reached by typing
Control-C followed by the first character of the construct.
\{m2-mode-map}
  Control-c b begin         Control-c c case
  Control-c d definition    Control-c e else
  Control-c f for           Control-c h header
  Control-c i if            Control-c m module
  Control-c l loop          Control-c o or
  Control-c p procedure     Control-c Control-w with
  Control-c r record        Control-c s stdio
  Control-c t type          Control-c u until
  Control-c v var           Control-c w while
  Control-c x export        Control-c y import
  Control-c { begin-comment Control-c } end-comment
  Control-c Control-z suspend-emacs     Control-c Control-t toggle
  Control-c Control-c compile           Control-x ` next-error
  Control-c Control-l link

   m2-indent controls the number of spaces for each indentation.
   m2-compile-command holds the command to compile a Modula-2 program.
   m2-link-command holds the command to link a Modula-2 program.Fenable-command
Allow COMMAND to be executed without special confirmation from now on.
The user's .emacs file is altered so that this will apply
to future sessions.Fdisable-command
Require special confirmation to execute COMMAND from now on.
The user's .emacs file is altered so that this will apply
to future sessions.Fnroff-mode
Major mode for editing text intended for nroff to format.
\{nroff-mode-map}
Turning on Nroff mode runs text-mode-hook, then nroff-mode-hook.
Also, try nroff-electric-mode, for automatically inserting
closing requests for requests that are used in matched pairs.Flist-options
Display a list of Emacs user options, with values and documentation.Fedit-options
Edit a list of Emacs user option values.
Selects a buffer containing such a list,
in which there are commands to set the option values.
Type \[describe-mode] in that buffer for a list of commands.Foutline-mode
Set major mode for editing outlines with selective display.
Headings are lines which start with asterisks: one for major headings,
two for subheadings, etc.  Lines not starting with asterisks are body lines.

Body text or subheadings under a heading can be made temporarily
invisible, or visible again.  Invisible lines are attached to the end
of the heading, so they move with it, if the line is killed and yanked
back.  A heading with text hidden under it is marked with an ellipsis (...).

Commands:
C-c C-n   outline-next-visible-heading      move by visible headings
C-c C-p   outline-previous-visible-heading
C-c C-f   outline-forward-same-level        similar but skip subheadings
C-c C-b   outline-backward-same-level
C-c C-u   outline-up-heading            move from subheading to heading

Meta-x hide-body    make all text invisible (not headings).
Meta-x show-all        make everything in buffer visible.

The remaining commands are used when point is on a heading line.
They apply to some of the body or subheadings of that heading.
C-c C-h   hide-subtree    make body and subheadings invisible.
C-c C-s   show-subtree    make body and subheadings visible.
C-c C-i   show-children    make direct subheadings visible.
         No effect on body, or subheadings 2 or more levels down.
         With arg N, affects subheadings N levels down.
M-x hide-entry       make immediately following body invisible.
M-x show-entry       make it visible.
M-x hide-leaves       make body under heading and under its subheadings invisible.
             The subheadings remain visible.
M-x show-branches  make all subheadings at all levels visible.

The variable outline-regexp can be changed to control what is a heading.
A line is a heading if outline-regexp matches something at the
beginning of the line.  The longer the match, the deeper the level.

Turning on outline mode calls the value of text-mode-hook and then of
outline-mode-hook, if they are non-nil.Fedit-picture
Switch to Picture mode, in which a quarter-plane screen model is used.
Printing characters replace instead of inserting themselves with motion
afterwards settable by these commands:
  C-c <      Move left after insertion.
  C-c >      Move right after insertion.
  C-c ^      Move up after insertion.
  C-c .      Move down after insertion.
  C-c `      Move northwest (nw) after insertion.
  C-c '      Move northeast (ne) after insertion.
  C-c /      Move southwest (sw) after insertion.
  C-c \   Move southeast (se) after insertion.
The current direction is displayed in the mode line.  The initial
direction is right.  Whitespace is inserted and tabs are changed to
spaces when required by movement.  You can move around in the buffer
with these commands:
  C-p      Move vertically to SAME column in previous line.
  C-n      Move vertically to SAME column in next line.
  C-e      Move to column following last non-whitespace character.
  C-f      Move right inserting spaces if required.
  C-b      Move left changing tabs to spaces if required.
  C-c C-f Move in direction of current picture motion.
  C-c C-b Move in opposite direction of current picture motion.
  Return  Move to beginning of next line.
You can edit tabular text with these commands:
  M-Tab      Move to column beneath (or at) next interesting charecter.
        `Indents' relative to a previous line.
  Tab      Move to next stop in tab stop list.
  C-c Tab Set tab stops according to context of this line.
        With ARG resets tab stops to default (global) value.
        See also documentation of variable    picture-tab-chars
        which defines "interesting character".  You can manually
        change the tab stop list with command \[edit-tab-stops].
You can manipulate text with these commands:
  C-d      Clear (replace) ARG columns after point without moving.
  C-c C-d Delete char at point - the command normally assigned to C-d.
  Delete  Clear (replace) ARG columns before point, moving back over them.
  C-k      Clear ARG lines, advancing over them.     The cleared
        text is saved in the kill ring.
  C-o      Open blank line(s) beneath current line.
You can manipulate rectangles with these commands:
  C-c C-k Clear (or kill) a rectangle and save it.
  C-c C-w Like C-c C-k except rectangle is saved in named register.
  C-c C-y Overlay (or insert) currently saved rectangle at point.
  C-c C-x Like C-c C-y except rectangle is taken from named register.
  \[copy-rectangle-to-register]   Copies a rectangle to a register.
  \[advertised-undo]   Can undo effects of rectangle overlay commands
        commands if invoked soon enough.
You can return to the previous mode with:
  C-c C-c Which also strips trailing whitespace from every line.
        Stripping is suppressed by supplying an argument.

Entry to this mode calls the value of  edit-picture-hook  if non-nil.

Note that Picture mode commands will work outside of Picture mode, but
they are not defaultly assigned to keys.Fprolog-mode
Major mode for editing Prolog code for Prologs.
Blank lines and `%%...' separate paragraphs.  `%'s start comments.
Commands:
\{prolog-mode-map}
Entry to this mode calls the value of prolog-mode-hook
if that value is non-nil.Frun-prolog
Run an inferior Prolog process, input and output via buffer *prolog*.Fclear-rectangle
Blank out rectangle with corners at point and mark.
The text previously in the region is overwritten by the blanks.Fdelete-rectangle
Delete (don't save) text in rectangle with point and mark as corners.
The same range of columns is deleted in each line
starting with the line where the region begins
and ending with the line where the region ends.Fdelete-extract-rectangle
Return and delete contents of rectangle with corners at START and END.
Value is list of strings, one for each line of the rectangle.Fextract-rectangle
Return contents of rectangle with corners at START and END.
Value is list of strings, one for each line of the rectangle.Finsert-rectangle
Insert text of RECTANGLE with upper left corner at point.
RECTANGLE's first line is inserted at point,
its second line is inserted at a point vertically under point, etc.
RECTANGLE should be a list of strings.Fkill-rectangle
Delete rectangle with corners at point and mark; save as last killed one.
Calling from program, supply two args START and END, buffer positions.
But in programs you might prefer to use delete-extract-rectangle.Fopen-rectangle
Blank out rectangle with corners at point and mark, shifting text right.
The text previously in the region is not overwritten by the blanks,
but insted winds up to the right of the rectangle.Fyank-rectangle
Yank the last killed rectangle with upper left corner at point.Frnews
Read USENET news for groups for which you are a member and add or
delete groups.
You can reply to articles posted and send articles to any group.

Type \[describe-mode] once reading news to get a list of rnews commands.Fnews-post-news
Begin editing a new USENET news article to be posted.
Type \[describe-mode] once editing the article to get a list of commands.Frmail
Read and edit incoming mail.
Moves messages into file named by  rmail-file-name  (a babyl format file)
 and edits that file in RMAIL Mode.
Type \[describe-mode] once editing that file, for a list of RMAIL commands.

May be called with filename as argument;
then performs rmail editing on that file,
but does not copy any new mail into the file.Frmail-input
Run RMAIL on file FILENAME.Vrmail-dont-reply-to-names
*A regular expression specifying names to prune in replying to messages.
nil means don't reply to yourself.Vrmail-default-dont-reply-to-names
A regular expression specifying part of the value of the default value of
the variable `rmail-dont-reply-to-names', for when the user does not set
`rmail-dont-reply-to-names' explicitly.  (The other part of the default
value is the user's name.)
It is useful to set this variable in the site customisation file.Vrmail-primary-inbox-list
*List of files which are inboxes for user's primary mail file ~/RMAIL.
`nil' means the default, which is ("~/mbox" "/usr/spool/mail/$USER")
(the second name varies depending on the operating system).Vrmail-ignored-headers
*Gubbish header fields one would rather not see.Vrmail-delete-after-output
*Non-nil means automatically delete a message that is copied to a file.Frun-scheme
Run an inferior Scheme process.
Output goes to the buffer `*scheme*'.
With argument, asks for a command line.Fscheme-mode
Major mode for editing Scheme code.
Editing commands are similar to those of lisp-mode.

In addition, if an inferior Scheme process is running, some additional
commands will be defined, for evaluating expressions and controlling
the interpreter, and the state of the process will be displayed in the
modeline of all Scheme buffers.  The names of commands that interact
with the Scheme process start with "xscheme-".  For more information
see the documentation for xscheme-interaction-mode.

Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{scheme-mode-map}
Entry to this mode calls the value of scheme-mode-hook
if that value is non-nil.Fscribe-mode
Major mode for editing files of Scribe (a text formatter) source.
Scribe-mode is similar text-mode, with a few extra commands added.
\{scribe-mode-map}

Interesting variables:

scribe-fancy-paragraphs
  Non-nil makes Scribe mode use a different style of paragraph separation.

scribe-electric-quote
  Non-nil makes insert of double quote use `` or '' depending on context.

scribe-electric-parenthesis
  Non-nil makes an open-parenthesis char (one of `([<{')
  automatically insert its close if typed after an @Command form.Vsend-mail-function
Function to call to send the current buffer as mail.
The headers are delimited by a string found in mail-header-separator.Vmail-self-blind
*Non-nil means insert BCC to self in messages to be sent.
This is done when the message is initialized,
so you can remove or alter the BCC field to override the default.Vmail-interactive
*Non-nil means when sending a message wait for and display errors.
nil means let mailer mail back a message to report errors.Vmail-yank-ignored-headers
Delete these headers from old message when it's inserted in a reply.Vmail-header-separator
*Line used to separate headers from text in messages being composed.Vmail-archive-file-name
*Name of file to write all outgoing messages in, or nil for none.Vmail-aliases
Alias of mail address aliases,
or t meaning should be initialized from .mailrc.Fmail-other-window
Like `mail' command, but display mail buffer in another window.Fmail
Edit a message to be sent.  Argument means resume editing (don't erase).
Returns with message buffer selected; value t if message freshly initialized.
While editing message, type C-c C-c to send the message and exit.

Various special commands starting with C-c are available in sendmail mode
to move to message header fields:
\{mail-mode-map}

If mail-self-blind is non-nil, a BCC to yourself is inserted
when the message is initialized.

If mail-default-reply-to is non-nil, it should be an address (a string);
a Reply-to: field with that address is inserted.

If mail-archive-file-name is non-nil, an FCC field with that file name
is inserted.

If mail-setup-hook is bound, its value is called with no arguments
after the message is initialized.  It can add more default fields.

When calling from a program, the second through fifth arguments
 TO, SUBJECT, IN-REPLY-TO and CC specify if non-nil
 the initial contents of those header fields.
 These arguments should not have final newlines.
The sixth argument REPLYBUFFER is a buffer whose contents
 should be yanked if the user types C-c C-y.Vmail-use-rfc822
*If non-nil, use a full, hairy RFC822 parser on mail addresses.
Otherwise, (the default) use a smaller, somewhat faster and
often-correct parser.Fserver-start
Allow this Emacs process to be a server for client processes.
This starts a server communications subprocess through which
client "editors" can send your editing commands to this Emacs job.
To use the server, set up the program `etc/emacsclient' in the
Emacs distribution as your standard "editor".

Prefix arg means just kill any existing server communications subprocess.Frun-lisp
Run an inferior Lisp process, input and output via buffer *lisp*.Fshell
Run an inferior shell, with I/O through buffer *shell*.
If buffer exists but shell process is not running, make new shell.
Program used comes from variable explicit-shell-file-name,
 or (if that is nil) from the ESHELL environment variable,
 or else from SHELL if there is no ESHELL.
If a file ~/.emacs_SHELLNAME exists, it is given as initial input
 (Note that this may lose due to a timing error if the shell
  discards input when it starts up.)
The buffer is put in shell-mode, giving commands for sending input
and controlling the subjobs of the shell.  See shell-mode.
See also variable shell-prompt-pattern.

The shell file name (sans directories) is used to make a symbol name
such as `explicit-csh-arguments'.  If that symbol is a variable,
its value is used as a list of arguments when invoking the shell.
Otherwise, one argument `-i' is passed to the shell.

Note that many people's .cshrc files unconditionally clear the prompt.
If yours does, you will probably want to change it.Fsort-lines
Sort lines in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).Fsort-paragraphs
Sort paragraphs in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).Fsort-pages
Sort pages in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).Fsort-numeric-fields
Sort lines in region numerically by the ARGth field of each line.
Fields are separated by whitespace and numbered from 1 up.
Specified field must contain a number in each line of the region.
With a negative arg, sorts by the -ARG'th field, in reverse order.
Called from a program, there are three arguments:
FIELD, BEG and END.  BEG and END specify region to sort.Fsort-fields
Sort lines in region lexicographically by the ARGth field of each line.
Fields are separated by whitespace and numbered from 1 up.
With a negative arg, sorts by the -ARG'th field, in reverse order.
Called from a program, there are three arguments:
FIELD, BEG and END.  BEG and END specify region to sort.Fsort-columns
Sort lines in region alphabetically by a certain range of columns.
For the purpose of this command, the region includes
the entire line that point is in and the entire line the mark is in.
The column positions of point and mark bound the range of columns to sort on.
A prefix argument means sort into reverse order.

Note that sort-columns uses the sort utility program and therefore
cannot work on text containing TAB characters.  Use M-x untabify
to convert tabs to spaces before sorting.Fsort-regexp-fields
Sort the region lexicographically as specifed by RECORD-REGEXP and KEY.
RECORD-REGEXP specifies the textual units which should be sorted.
  For example, to sort lines RECORD-REGEXP would be "^.*$"
KEY specifies the part of each record (ie each match for RECORD-REGEXP)
  is to be used for sorting.
  If it is "\digit" then the digit'th "\(...\)" match field from
  RECORD-REGEXP is used.
  If it is "\&" then the whole record is used.
  Otherwise, it is a regular-expression for which to search within the record.
If a match for KEY is not found within a record then that record is ignored.

With a negative prefix arg sorts in reverse order.

For example: to sort lines in the region by the first word on each line
 starting with the letter "f",
 RECORD-REGEXP would be "^.*$" and KEY "\<f\w*\>"Fspell-buffer
Check spelling of every word in the buffer.
For each incorrect word, you are asked for the correct spelling
and then put into a query-replace to fix some or all occurrences.
If you do not want to change a word, just give the same word
as its "correct" spelling; then the query replace is skipped.Fspell-region
Like spell-buffer but applies only to region.
From program, applies from START to END.Fspell-word
Check spelling of word at or before point.
If it is not correct, ask user for the correct spelling
and query-replace the entire buffer to substitute it.Fspell-string
Check spelling of string supplied as argument.Funtabify
Convert all tabs in region to multiple spaces, preserving columns.
The variable tab-width controls the action.Ftabify
Convert multiple spaces in region to tabs when possible.
A group of spaces is partially replaced by tabs
when this can be done without changing the column they end at.
The variable tab-width controls the action.Ffind-tag
Find tag (in current tag table) whose name contains TAGNAME.
 Selects the buffer that the tag is contained in
and puts point at its definition.
 If TAGNAME is a null string, the expression in the buffer
around or before point is used as the tag name.
 If second arg NEXT is non-nil (interactively, with prefix arg),
searches for the next tag in the tag table
that matches the tagname used in the previous find-tag.

See documentation of variable tags-file-name.Ffind-tag-other-window
Find tag (in current tag table) whose name contains TAGNAME.
 Selects the buffer that the tag is contained in in another window
and puts point at its definition.
 If TAGNAME is a null string, the expression in the buffer
around or before point is used as the tag name.
 If second arg NEXT is non-nil (interactively, with prefix arg),
searches for the next tag in the tag table
that matches the tagname used in the previous find-tag.

See documentation of variable tags-file-name.Flist-tags
Display list of tags in file FILE.
FILE should not contain a directory spec
unless it has one in the tag table.Fnext-file
Select next file among files in current tag table.
Non-nil argument (prefix arg, if interactive)
initializes to the beginning of the list of files in the tag table.Ftags-apropos
Display list of all tags in tag table REGEXP matches.Ftags-loop-continue
Continue last \[tags-search] or \[tags-query-replace] command.
Used noninteractively with non-nil argument
to begin such a command.  See variable tags-loop-form.Ftag-table-files
Return a list of files in the current tag table.
File names returned are absolute.Ftags-query-replace
Query-replace-regexp FROM with TO through all files listed in tag table.
Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
If you exit (C-G or ESC), you can resume the query-replace
with the command \[tags-loop-continue].

See documentation of variable tags-file-name.Ftags-search
Search through all files listed in tag table for match for REGEXP.
Stops when a match is found.
To continue searching for next match, use command \[tags-loop-continue].

See documentation of variable tags-file-name.Fvisit-tags-table
Tell tags commands to use tag table file FILE.
FILE should be the name of a file created with the `etags' program.
A directory name is ok too; it means file TAGS in that directory.Ftelnet
Open a network login connection to host named HOST (a string).
Communication with HOST is recorded in a buffer *HOST-telnet*.
Normally input is edited in Emacs and sent a line at a time.Fterminal-emulator
Under a display-terminal emulator in BUFFER, run PROGRAM on arguments ARGS.
ARGS is a list of argument-strings.  Remaining arguments are WIDTH and HEIGHT.
BUFFER's contents are made an image of the display generated by that program,
and any input typed when BUFFER is the current Emacs buffer is sent to that
program an keyboard input.

Interactively, BUFFER defaults to "*terminal*" and PROGRAM and ARGS
are parsed from an input-string using your usual shell.
WIDTH and HEIGHT are determined from the size of the current window
-- WIDTH will be one less than the window's width, HEIGHT will be its height.

To switch buffers and leave the emulator, or to give commands
to the emulator itself (as opposed to the program running under it),
type Control-^.  The following character is an emulator command.
Type Control-^ twice to send it to the subprogram.
This escape character may be changed using the variable `terminal-escape-char'.

`Meta' characters may not currently be sent through the terminal emulator.

Here is a list of some of the variables which control the behaviour
of the emulator -- see their documentation for more information:
terminal-escape-char, terminal-scrolling, terminal-more-processing,
terminal-redisplay-interval.

This function calls the value of terminal-mode-hook if that exists
and is non-nil after the terminal buffer has been set up and the
subprocess started.

Presently with `termcap' only; if somebody sends us code to make this
work with `terminfo' we will try to use it.Flatex-mode
Major mode for editing files of input for LaTeX.
Makes $ and } display the characters they match.
Makes " insert `` when it seems to be the beginning of a quotation,
and '' when it appears to be the end; it inserts " only after a \.

Use \[TeX-region] to run LaTeX on the current region, plus the preamble
copied from the top of the file (containing \documentstyle, etc.),
running LaTeX under a special subshell.  \[TeX-buffer] does the whole buffer.
\[TeX-print] prints the .dvi file made by either of these.

Use \[validate-TeX-buffer] to check buffer for paragraphs containing
mismatched $'s or braces.

Special commands:
\{TeX-mode-map}

Mode variables:
TeX-directory
    Directory in which to create temporary files for TeX jobs
    run by \[TeX-region] or \[TeX-buffer].
TeX-dvi-print-command
    Command string used by \[TeX-print] to print a .dvi file.
TeX-show-queue-command
    Command string used by \[TeX-show-print-queue] to show the print
    queue that \[TeX-print] put your job on.

Entering LaTeX mode calls the value of text-mode-hook,
then the value of TeX-mode-hook, and then the value
of LaTeX-mode-hook.Fplain-tex-mode
Major mode for editing files of input for plain TeX.
Makes $ and } display the characters they match.
Makes " insert `` when it seems to be the beginning of a quotation,
and '' when it appears to be the end; it inserts " only after a \.

Use \[TeX-region] to run TeX on the current region, plus a "header"
copied from the top of the file (containing macro definitions, etc.),
running TeX under a special subshell.  \[TeX-buffer] does the whole buffer.
\[TeX-print] prints the .dvi file made by either of these.

Use \[validate-TeX-buffer] to check buffer for paragraphs containing
mismatched $'s or braces.

Special commands:
\{TeX-mode-map}

Mode variables:
TeX-directory
    Directory in which to create temporary files for TeX jobs
    run by \[TeX-region] or \[TeX-buffer].
TeX-dvi-print-command
    Command string used by \[TeX-print] to print a .dvi file.
TeX-show-queue-command
    Command string used by \[TeX-show-print-queue] to show the print
    queue that \[TeX-print] put your job on.

Entering plain-TeX mode calls the value of text-mode-hook,
then the value of TeX-mode-hook, and then the value
of plain-TeX-mode-hook.Ftex-mode
Major mode for editing files of input for TeX or LaTeX.
Trys to intuit whether this file is for plain TeX or LaTeX and
calls plain-tex-mode or latex-mode.  If it cannot be determined
(e.g., there are no commands in the file), the value of
TeX-default-mode is used.Ftexinfo-mode
Major mode for editing texinfo files.
These are files that are input for TEX and also to be turned
into Info files by \[texinfo-format-buffer].
These files must be written in a very restricted and
modified version of TEX input format.

As for editing commands, like text-mode except for syntax table,
which is set up so expression commands skip texinfo bracket groups.Ftexinfo-format-buffer
Process the current buffer as texinfo code, into an Info file.
The Info file output is generated in a buffer
visiting the Info file names specified in the @setfilename command.

Non-nil argument (prefix, if interactive) means don't make tag table
and don't split the file if large.  You can use Info-tagify and
Info-split to do these manually.Ftexinfo-format-region
Convert the the current region of the Texinfo file to Info format.
This lets you see what that part of the file will look like in Info.
The command is bound to \[texinfo-format-region].  The text that is
converted to Info is stored in a temporary buffer.Fbatch-texinfo-format
Runs  texinfo-format-buffer  on the files remaining on the command line.
Must be used only with -batch, and kills emacs on completion.
Each file will be processed even if an error occurred previously.
For example, invoke
  "emacs -batch -funcall batch-texinfo-format $docs/ ~/*.texinfo".Fdisplay-time
Display current time and load level in mode line of each buffer.
Updates automatically every minute.
If display-time-day-and-date is non-nil, the current day and date
are displayed as well.Funderline-region
Underline all nonblank characters in the region.
Works by overstriking underscores.
Called from program, takes two arguments START and END
which specify the range to operate on.Fununderline-region
Remove all underlining (overstruck underscores) in the region.
Called from program, takes two arguments START and END
which specify the range to operate on.Fask-user-about-lock
Ask user what to do when he wants to edit FILE but it is locked by USER.
This function has a choice of three things to do:
  do (signal 'buffer-file-locked (list FILE USER))
    to refrain from editing the file
  return t (grab the lock on the file)
  return nil (edit the file even though it is locked).
You can rewrite it to use any criterion you like to choose which one to do.Fask-user-about-supersession-threat
Ask a user who is about to modify an obsolete buffer what to do.
This function has two choices: it can return, in which case the modification
of the buffer will proceed, or it can (signal 'file-supersession (file)),
in which case the proposed buffer modification will not be made.
You can rewrite this to use any criterion you like to choose which one to do.Fvi-mode
Major mode that acts like the `vi' editor.
The purpose of this mode is to provide you the combined power of vi (namely,
the "cross product" effect of commands and repeat last changes) and Emacs.

This command redefines nearly all keys to look like vi commands.
It records the previous major mode, and any vi command for input
(`i', `a', `s', etc.) switches back to that mode.
Thus, ordinary Emacs (in whatever major mode you had been using)
is "input" mode as far as vi is concerned.

To get back into vi from "input" mode, you must issue this command again.
Therefore, it is recommended that you assign it to a key.

Major differences between this mode and real vi :

* Limitations and unsupported features
  - Search patterns with line offset (e.g. /pat/+3 or /pat/z.) are
    not supported.
  - Ex commands are not implemented; try ':' to get some hints.
  - No line undo (i.e. the 'U' command), but multi-undo is a standard feature.

* Modifications
  - The stopping positions for some point motion commands (word boundary,
    pattern search) are slightly different from standard 'vi'.
    Also, no automatic wrap around at end of buffer for pattern searching.
  - Since changes are done in two steps (deletion then insertion), you need
    to undo twice to completely undo a change command.  But this is not needed
    for undoing a repeated change command.
  - No need to set/unset 'magic', to search for a string with regular expr
    in it just put a prefix arg for the search commands.  Replace cmds too.
  - ^R is bound to incremental backward search, so use ^L to redraw screen.

* Extensions
  - Some standard (or modified) Emacs commands were integrated, such as
    incremental search, query replace, transpose objects, and keyboard macros.
  - In command state, ^X links to the 'ctl-x-map', and ESC can be linked to
    esc-map or set undefined.  These can give you the full power of Emacs.
  - See vi-com-map for those keys that are extensions to standard vi, e.g.
    `vi-name-last-change-or-macro', `vi-verify-spelling', `vi-locate-def',
    `vi-mark-region', and 'vi-quote-words'.  Some of them are quite handy.
  - Use \[vi-switch-mode] to switch among different modes quickly.

Syntax table and abbrevs while in vi mode remain as they were in Emacs.Fview-file
View FILE in View mode, returning to previous buffer when done.
The usual Emacs commands are not available; instead,
a special set of commands (mostly letters and punctuation)
are defined for moving around in the buffer.
Space scrolls forward, Delete scrolls backward.
For list of all View commands, type ? or h while viewing.

Calls the value of  view-hook  if that is non-nil.Fview-buffer
View BUFFER in View mode, returning to previous buffer when done.
The usual Emacs commands are not available; instead,
a special set of commands (mostly letters and punctuation)
are defined for moving around in the buffer.
Space scrolls forward, Delete scrolls backward.
For list of all View commands, type ? or h while viewing.

Calls the value of  view-hook  if that is non-nil.Fview-mode
Major mode for viewing text but not editing it.
Letters do not insert themselves.  Instead these commands are provided.
Most commands take prefix arguments.  Commands dealing with lines
default to "scroll size" lines (initially size of window).
Search commands default to a repeat count of one.
M-< or <    move to beginning of buffer.
M-> or >    move to end of buffer.
C-v or Space    scroll forward lines.
M-v or DEL    scroll backward lines.
CR or LF    scroll forward one line (backward with prefix argument).
z        like Space except set number of lines for further
           scrolling commands to scroll by.
C-u and Digits    provide prefix arguments.  `-' denotes negative argument.
=        prints the current line number.
g        goes to line given by prefix argument.
/ or M-C-s    searches forward for regular expression
\ or M-C-r    searches backward for regular expression.
n        searches forward for last regular expression.
p        searches backward for last regular expression.
C-@ or .    set the mark.
x        exchanges point and mark.
C-s or s    do forward incremental search.
C-r or r    do reverse incremental search.
@ or '        return to mark and pops mark ring.
          Mark ring is pushed at start of every
          successful search and when jump to line to occurs.
          The mark is set on jump to buffer start or end.
? or h        provide help message (list of commands).
C-h        provides help (list of commands or description of a command).
C-n        moves down lines vertically.
C-p        moves upward lines vertically.
C-l        recenters the screen.
q or C-c    exit view-mode and return to previous buffer.

Entry to this mode calls the value of  view-hook  if non-nil.
\{view-mode-map}Fvip-mode
Begin emulating the vi editor.  This is distinct from `vi-mode'.
This emulator has different capabilities from the `vi-mode' emulator.
See the text at the beginning of the source file .../lisp/vip.el
in the Emacs distribution.Fyow
Return or display a Zippy quotationFpsychoanalyze-pinhead
Zippy goes to the analyst.Fisearch-forward
Do incremental search forward.
As you type characters, they add to the search string and are found.
Type Delete to cancel characters from end of search string.
Type ESC to exit, leaving point at location found.
Type C-s to search again forward, C-r to search again backward.
Type C-w to yank word from buffer onto end of search string and search for it.
Type C-y to yank rest of line onto end of search string, etc.
Type C-q to quote control character to search for it.
Other control and meta characters terminate the search
 and are then executed normally.
The above special characters are mostly controlled by parameters;
 do M-x apropos on search-.*-char to find them.
C-g while searching or when search has failed
 cancels input back to what has been found successfully.
C-g when search is successful aborts and moves point to starting point.Fisearch-forward-regexp
Do incremental search forward for regular expression.
Like ordinary incremental search except that your input
is treated as a regexp.  See \[isearch-forward] for more info.Fisearch-backward
Do incremental search backward.
See \[isearch-forward] for more information.Fisearch-backward-regexp
Do incremental search backward for regular expression.
Like ordinary incremental search except that your input
is treated as a regexp.  See \[isearch-forward] for more info.Vsearch-last-string
Last string search for by a non-regexp search command.
This does not include direct calls to the primitive search functions,
and does not include searches that are aborted.Vsearch-last-regexp
Last string searched for by a regexp search command.
This does not include direct calls to the primitive search functions,
and does not include searches that are aborted.Vsearch-repeat-char
*Character to repeat incremental search forwards.Vsearch-reverse-char
*Character to repeat incremental search backwards.Vsearch-exit-char
*Character to exit incremental search.Vsearch-delete-char
*Character to delete from incremental search string.Vsearch-quote-char
*Character to quote special characters for incremental search.Vsearch-yank-word-char
*Character to pull next word from buffer into search string.Vsearch-yank-line-char
*Character to pull rest of line from buffer into search string.Vsearch-exit-option
*Non-nil means random control characters terminate incremental search.Vsearch-slow-window-lines
*Number of lines in slow search display windows.
These are the short windows used during incremental search on slow terminals.
Negative means put the slow search window at the top (normally it's at bottom)
and the value is minus the number of lines.Vsearch-slow-speed
*Highest terminal speed at which to use "slow" style incremental search.
This is the style where a one-line window is created to show the line
that the search has reached.Fquery-replace
Replace some occurrences of FROM-STRING with TO-STRING.
As each match is found, the user must type a character saying
what to do with it.  For directions, type \[help-command] at that time.

Preserves case in each replacement if  case-replace  and  case-fold-search
are non-nil and FROM-STRING has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.Fquery-replace-regexp
Replace some things after point matching REGEXP with TO-STRING.
As each match is found, the user must type a character saying
what to do with it.  For directions, type \[help-command] at that time.

Preserves case in each replacement if  case-replace  and  case-fold-search
are non-nil and REGEXP has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
In TO-STRING, \& means insert what matched REGEXP,
and \=\<n> means insert what matched <n>th \(...\) in REGEXP.Freplace-string
Replace occurrences of FROM-STRING with TO-STRING.
Preserve case in each match if  case-replace  and  case-fold-search
are non-nil and FROM-STRING has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.Freplace-regexp
Replace things after point matching REGEXP with TO-STRING.
Preserve case in each match if case-replace and case-fold-search
are non-nil and REGEXP has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
In TO-STRING, \& means insert what matched REGEXP,
and \=\<n> means insert what matched <n>th \(...\) in REGEXP.Vcommand-line-processed
t once command line has been processedVinhibit-startup-message
*Non-nil inhibits the initial startup messages.
This is for use in your personal init file, once you are familiar
with the contents of the startup message.Vinhibit-default-init
*Non-nil inhibits loading the `default' library.Vcommand-switch-alist
Alist of command-line switches.
Elements look like (SWITCH-STRING . HANDLER-FUNCTION).
HANDLER-FUNCTION receives switch name as sole arg;
remaining command-line args are in the variable `command-line-args-left'.Vterm-setup-hook
Function to be called after loading terminal-specific lisp code.
It is called with no arguments.  You can use this to override the
definitions made by the terminal-specific file.Vinitial-major-mode
Major mode command symbol to use for the initial *scratch* buffer.Fforward-sexp
Move forward across one balanced expression.
With argument, do this that many times.Fbackward-sexp
Move backward across one balanced expression.
With argument, do this that many times.Fmark-sexp
Set mark ARG sexps from point.Fforward-list
Move forward across one balanced group of parentheses.
With argument, do this that many times.Fbackward-list
Move backward across one balanced group of parentheses.
With argument, do this that many times.Fdown-list
Move forward down one level of parentheses.
With argument, do this that many times.
A negative argument means move backward but still go down a level.Fbackward-up-list
Move backward out of one level of parentheses.
With argument, do this that many times.
A negative argument means move forward but still to a less deep spot.Fup-list
Move forward out of one level of parentheses.
With argument, do this that many times.
A negative argument means move backward but still to a less deep spot.Fkill-sexp
Kill the syntactic expression following the cursor.
With argument, kill that many expressions after (or before) the cursor.Fbackward-kill-sexp
Kill the syntactic expression preceding the cursor.
With argument, kill that many expressions before (or after) the cursor.Fbeginning-of-defun
Move backward to next beginning-of-defun.
With argument, do this that many times.
Returns t unless search stops due to end of buffer.Fend-of-defun
Move forward to next end of defun.
An end of a defun is found by moving forward from the beginning of one.Fmark-defun
Put mark at end of defun, point at beginning.Finsert-parentheses
Put parentheses around next ARG sexps.  Leave point after open-paren.
No argument is equivalent to zero: just insert () and leave point between.Fmove-past-close-and-reindent
Move past next ), delete indentation before it, then indent after it.Flisp-complete-symbol
Perform completion on Lisp symbol preceding point.
That symbol is compared against the symbols that exist
and any additional characters determined by what is there
are inserted.
If the symbol starts just after an open-parenthesis,
only symbols with function definitions are considered.
Otherwise, all symbols with function definitions, values
or properties are considered.Fforward-page
Move forward to page boundary.  With arg, repeat, or go back if negative.
A page boundary is any line whose beginning matches the regexp  page-delimiter.Fbackward-page
Move backward to page boundary.  With arg, repeat, or go fwd if negative.
A page boundary is any line whose beginning matches the regexp  page-delimiter.Fmark-page
Put mark at end of page, point at beginning.
A numeric arg specifies to move forward or backward by that many pages,
thus marking a page other than the one point was originally in.Fnarrow-to-page
Make text outside current page invisible.
A numeric arg specifies to move forward or backward by that many pages,
thus showing a page other than the one point was originally in.Fcount-lines-page
Report number of lines on current page, and how many are before or after point.Fwhat-page
Print page and line number of point.Vregister-alist
Alist of elements (NAME . CONTENTS), one for each Emacs register.
NAME is a character (a number).  CONTENTS is a string, number,
mark or list.  A list represents a rectangle; its elements are strings.Fget-register
Return contents of Emacs register named CHAR, or nil if none.Fset-register
Set contents of Emacs register named CHAR to VALUE.Fpoint-to-register
Store current location of point in a register.
Argument is a character, naming the register.Fregister-to-point
Move point to location stored in a register.
Argument is a character, naming the register.Fview-register
Display what is contained in register named REGISTER.
REGISTER is a character.Finsert-register
Insert contents of register REG.  REG is a character.
Normally puts point before and mark after the inserted text.
If optional second arg is non-nil, puts mark before and point after.
Interactively, second arg is non-nil if prefix arg is supplied.Fcopy-to-register
Copy region into register REG.
With prefix arg, delete as well.
Called from program, takes four args:
REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to copy.Fappend-to-register
Append region to text in register REG.
With prefix arg, delete as well.
Called from program, takes four args:
REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to append.Fprepend-to-register
Prepend region to text in register REG.
With prefix arg, delete as well.
Called from program, takes four args:
REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to prepend.Fcopy-rectangle-to-register
Copy rectangular region into register REG.
With prefix arg, delete as well.
Called from program, takes four args:
REG, START, END and DELETE-FLAG.
START and END are buffer positions giving two corners of rectangle.Vparagraph-ignore-fill-prefix
Non-nil means the paragraph commands are not affected by fill-prefix.
This is desirable in modes where blank lines are the paragraph delimiters.Fforward-paragraph
Move forward to end of paragraph.  With arg, do it arg times.
A line which  paragraph-start  matches either separates paragraphs
(if  paragraph-separate  matches it also) or is the first line of a paragraph.
A paragraph end is the beginning of a line which is not part of the paragraph
to which the end of the previous line belongs, or the end of the buffer.Fbackward-paragraph
Move backward to start of paragraph.  With arg, do it arg times.
A paragraph start is the beginning of a line which is a first-line-of-paragraph
or which is ordinary text and follows a paragraph-separating line; except:
if the first real line of a paragraph is preceded by a blank line,
the paragraph starts at that blank line.
See forward-paragraph for more information.Fmark-paragraph
Put point at beginning of this paragraph, mark at end.Fkill-paragraph
Kill to end of paragraph.Fbackward-kill-paragraph
Kill back to start of paragraph.Ftranspose-paragraphs
Interchange this (or next) paragraph with previous one.Fforward-sentence
Move forward to next sentence-end.  With argument, repeat.
With negative argument, move backward repeatedly to sentence-beginning.
Sentence ends are identified by the value of sentence-end
treated as a regular expression.  Also, every paragraph boundary
terminates sentences as well.Fbackward-sentence
Move backward to start of sentence.  With arg, do it arg times.
See forward-sentence for more information.Fkill-sentence
Kill from point to end of sentence.
With arg, repeat, or backward if negative arg.Fbackward-kill-sentence
Kill back from point to start of sentence.
With arg, repeat, or forward if negative arg.Fmark-end-of-sentence
Put mark at end of sentence.  Arg works as in forward-sentence.Ftranspose-sentences
Interchange this (next) and previous sentence.Vlisp-mode-syntax-table
Vemacs-lisp-mode-syntax-table
Vlisp-mode-abbrev-table
Vemacs-lisp-mode-map
Femacs-lisp-mode
Major mode for editing Lisp code to run in Emacs.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{emacs-lisp-mode-map}
Entry to this mode calls the value of emacs-lisp-mode-hook
if that value is non-nil.Flisp-mode
Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{lisp-mode-map}
Note that `run-lisp' may be used either to start an inferior Lisp job
or to switch back to an existing one.

Entry to this mode calls the value of lisp-mode-hook
if that value is non-nil.Flisp-send-defun
Send the current defun to the Lisp process made by M-x run-lisp.Flisp-interaction-mode
Major mode for typing and evaluating Lisp forms.
Like Lisp mode except that \[eval-print-last-sexp] evals the Lisp expression
before point, and prints its value into the buffer, advancing point.

Commands:
Delete converts tabs to spaces as it moves back.
Paragraphs are separated only by blank lines.  Semicolons start comments.
\{lisp-interaction-mode-map}
Entry to this mode calls the value of lisp-interaction-mode-hook
if that value is non-nil.Feval-print-last-sexp
Evaluate sexp before point; print value into current buffer.Feval-last-sexp
Evaluate sexp before point; print value in minibuffer.
With argument, print output into current buffer.Feval-defun
Evaluate defun that point is in or before.
Print value in minibuffer.
With argument, insert value in current buffer after the defun.Vlisp-indent-offset
Vlisp-indent-hook
Flisp-indent-line
Indent current line as Lisp code.
With argument, indent any additional lines of the same expression
rigidly along with this one.Fcalculate-lisp-indent
Return appropriate indentation for current line as Lisp code.
In usual case returns an integer: the column to indent to.
Can instead return a list, whose car is the column to indent to.
This means that following lines at the same level of indentation
should not necessarily be indented the same way.
The second element of the list is the buffer position
of the start of the containing expression.Vlisp-body-indent
Findent-sexp
Indent each line of the list starting just after point.Findent-code-rigidly
Indent all lines of code, starting in the region, sideways by ARG columns.
Does not affect lines starting inside comments or strings,
assuming that the start of the region is not inside them.
Called from a program, takes args START, END, COLUMNS and NOCHANGE-REGEXP.
The last is a regexp which, if matched at the beginning of a line,
means don't indent that line.Vtext-mode-syntax-table
Syntax table used while in text mode.Vtext-mode-abbrev-table
Abbrev table used while in text mode.Vtext-mode-map
Ftext-mode
Major mode for editing text intended for humans to read.  Special commands:\{text-mode-map}
Turning on text-mode calls the value of the variable text-mode-hook,
if that value is non-nil.Findented-text-mode
Major mode for editing indented text intended for humans to read.\{indented-text-mode-map}
Turning on indented-text-mode calls the value of the variable text-mode-hook,
if that value is non-nil.Fcenter-paragraph
Center each line in the paragraph at or after point.
See center-line for more info.Fcenter-region
Center each line starting in the region.
See center-line for more info.Fcenter-line
Center the line point is on, within the width specified by `fill-column'.
This means adjusting the indentation to match
the distance between the end of the text and `fill-column'.Fset-fill-prefix
Set the fill-prefix to the current line up to point.
Filling expects lines to start with the fill prefix
and reinserts the fill prefix in each resulting line.Ffill-region-as-paragraph
Fill region as one paragraph: break lines to fit fill-column.
Prefix arg means justify too.
From program, pass args FROM, TO and JUSTIFY-FLAG.Ffill-paragraph
Fill paragraph at or after point.
Prefix arg means justify as well.Ffill-region
Fill each of the paragraphs in the region.
Prefix arg (non-nil third arg, if called from program)
means justify as well.Fjustify-current-line
Add spaces to line point is in, so it ends at fill-column.Ffill-individual-paragraphs
Fill each paragraph in region according to its individual fill prefix.
Calling from a program, pass range to fill as first two arguments.
Optional third and fourth arguments JUSTIFY-FLAG and MAIL-FLAG:
JUSTIFY-FLAG to justify paragraphs (prefix arg),
MAIL-FLAG for a mail message, i. e. don't fill header lines.Vc-mode-abbrev-table
Abbrev table in use in C-mode buffers.Vc-mode-map
Keymap used in C mode.Fc-macro-expand
Display the result of expanding all C macros occurring in the region.
The expansion is entirely correct because it uses the C preprocessor.Vc-mode-syntax-table
Syntax table in use in C-mode buffers.Vc-indent-level
*Indentation of C statements with respect to containing block.Vc-brace-imaginary-offset
*Imagined indentation of a C open brace that actually follows a statement.Vc-brace-offset
*Extra indentation for braces, compared with other text in same context.Vc-argdecl-indent
*Indentation level of declarations of C function arguments.Vc-label-offset
*Offset of C label lines and case statements relative to usual indentation.Vc-continued-statement-offset
*Extra indent for lines not starting new statements.Vc-continued-brace-offset
*Extra indent for substatements that start with open-braces.
This is in addition to c-continued-statement-offset.Vc-auto-newline
*Non-nil means automatically newline before and after braces,
and after colons and semicolons, inserted in C code.Vc-tab-always-indent
*Non-nil means TAB in C mode should always reindent the current line,
regardless of where in the line point is when the TAB command is used.Fc-mode
Major mode for editing C code.
Expression and list commands understand all C brackets.
Tab indents for C code.
Comments are delimited with /* ... */.
Paragraphs are separated by blank lines only.
Delete converts tabs to spaces as it moves back.
\{c-mode-map}
Variables controlling indentation style:
 c-tab-always-indent
    Non-nil means TAB in C mode should always reindent the current line,
    regardless of where in the line point is when the TAB command is used.
 c-auto-newline
    Non-nil means automatically newline before and after braces,
    and after colons and semicolons, inserted in C code.
 c-indent-level
    Indentation of C statements within surrounding block.
    The surrounding block's indentation is the indentation
    of the line on which the open-brace appears.
 c-continued-statement-offset
    Extra indentation given to a substatement, such as the
    then-clause of an if or body of a while.
 c-continued-brace-offset
    Extra indentation given to a brace that starts a substatement.
    This is in addition to c-continued-statement-offset.
 c-brace-offset
    Extra indentation for line if it starts with an open brace.
 c-brace-imaginary-offset
    An open brace following other text is treated as if it were
    this far to the right of the start of its line.
 c-argdecl-indent
    Indentation level of declarations of C function arguments.
 c-label-offset
    Extra indentation for line that is a label, or case or default.

Settings for K&R and BSD indentation styles are
  c-indent-level                5    8
  c-continued-statement-offset  5    8
  c-brace-offset               -5   -8
  c-argdecl-indent              0    8
  c-label-offset               -5   -8

Turning on C mode calls the value of the variable c-mode-hook with no args,
if that value is non-nil.Felectric-c-brace
Insert character and correct line's indentation.Felectric-c-semi
Insert character and correct line's indentation.Felectric-c-terminator
Insert character and correct line's indentation.Fc-indent-command
Indent current line as C code, or in some cases insert a tab character.
If c-tab-always-indent is non-nil (the default), always indent current line.
Otherwise, indent the current line only if point is at the left margin
or in the line's indentation; otherwise insert a tab.

A numeric argument, regardless of its value,
means indent rigidly all the lines of the expression starting after point
so that this line becomes properly indented.
The relative indentation among the lines of the expression are preserved.Fc-indent-line
Indent current line as C code.
Return the amount the indentation changed by.Fcalculate-c-indent
Return appropriate indentation for current line as C code.
In usual case returns an integer: the column to indent to.
Returns nil if line starts inside a string, t if in a comment.Fcalculate-c-indent-within-comment
Return the indentation amount for line, assuming that
the current line is to be regarded as part of a block comment.Fc-backward-to-start-of-if
Move to the start of the last ``unbalanced'' if.Fmark-c-function
Put mark at end of C function, point at beginning.Findent-c-exp
Indent each line of the C grouping following point.Vsearch-smart-case
*If non-nil, isearch turns off case-fold-search when the search string
contains both uppercase and lowercase.
If neither nil nor t, use smart case search even if case-fold-search is nil.
See also variable search-smart-case-predicate.Vsearch-smart-case-predicate
Predicate function that says case-fold-search shall remain true.
Predefined predicates are downcase-p, upcase-p and onecase-p.Fkeep-lines
Delete all lines except those containing matches for REGEXP.
A match split across lines preserves all the lines it lies in.
Applies to all lines after point.Fflush-lines
Delete lines containing matches for REGEXP.
If a match is split across lines, all the lines it lies in are deleted.
Applies to lines after point.Fhow-many
Print number of matches for REGEXP following point.Foccur-mode
Major mode for output from \[occur].
Move point to one of the occurrences in this buffer,
then use \[occur-mode-goto-occurrence] to go to the same occurrence
in the buffer that the occurrences were found in.
\{occur-mode-map}Foccur-mode-goto-occurrence
Go to the line this occurrence was found in, in the buffer it was found in.Vlist-matching-lines-default-context-lines
*Default number of context lines to include around a list-matching-lines
match.  A negative number means to include that many lines before the match.
A positive number means to include that many lines both before and after.Foccur
Show all lines following point containing a match for REGEXP.
Display each line with NLINES lines before and after,
 or -NLINES before if NLINES is negative.
NLINES defaults to list-matching-lines-default-context-lines.
Interactively it is the prefix arg.

The lines are shown in a buffer named *Occur*.
It serves as a menu to find any of the occurrences in this buffer.
\[describe-mode] in that buffer will explain how.Fabbrev-mode
Toggle abbrev mode.
With arg, turn abbrev mode on iff arg is positive.
In abbrev mode, inserting an abbreviation causes it to expand
and be replaced by its expansion.Vedit-abbrevs-map
Keymap used in edit-abbrevs.Fkill-all-abbrevs
Undefine all defined abbrevs.Finsert-abbrevs
Insert after point a description of all defined abbrevs.
Mark is set after the inserted text.Flist-abbrevs
Display a list of all defined abbrevs.Fedit-abbrevs-mode
Major mode for editing the list of abbrev definitions.
\{edit-abbrevs-map}Fedit-abbrevs
Alter abbrev definitions by editing a list of them.
Selects a buffer containing a list of abbrev definitions.
You can edit them and type C-c C-c to redefine abbrevs
according to your editing.
Buffer contains a header line for each abbrev table,
 which is the abbrev table name in parentheses.
This is followed by one line per abbrev in that table:
NAME   USECOUNT   EXPANSION   HOOK
where NAME and EXPANSION are strings with quotes,
USECOUNT is an integer, and HOOK is any valid function
or may be omitted (it is usually omitted).Fedit-abbrevs-redefine
Redefine abbrevs according to current buffer contents.Fdefine-abbrevs
Define abbrevs according to current visible buffer contents.
See documentation of edit-abbrevs for info on the format of the
text you must have in the buffer.
With argument, eliminate all abbrev definitions except
the ones defined from the buffer now.Fread-abbrev-file
Read abbrev definitions from file written with write-abbrev-file.
Takes file name as argument.
Optional second argument non-nil means don't print anything.Fquietly-read-abbrev-file
Read abbrev definitions from file written with write-abbrev-file.
Takes file name as argument.  Does not print anything.Fwrite-abbrev-file
Write all abbrev definitions to file of Lisp code.
The file can be loaded to define the same abbrevs.Fadd-mode-abbrev
Define mode-specific abbrev for last word(s) before point.
Argument is how many words before point form the expansion;
or zero means the region is the expansion.
A negative argument means to undefine the specified abbrev.
Reads the abbreviation in the minibuffer.Fadd-global-abbrev
Define global (all modes) abbrev for last word(s) before point.
Argument is how many words before point form the expansion;
or zero means the region is the expansion.
A negative argument means to undefine the specified abbrev.
Reads the abbreviation in the minibuffer.Finverse-add-mode-abbrev
Define last word before point as a mode-specific abbrev.
With argument N, defines the Nth word before point.
Reads the expansion in the minibuffer.
Expands the abbreviation after defining it.Finverse-add-global-abbrev
Define last word before point as a global (mode-independent) abbrev.
With argument N, defines the Nth word before point.
Reads the expansion in the minibuffer.
Expands the abbreviation after defining it.Fabbrev-prefix-mark
Mark current point as the beginning of an abbrev.
Abbrev to be expanded starts here rather than at
beginning of word.  This way, you can expand an abbrev
with a prefix: insert the prefix, use this command,
then insert the abbrev.Fexpand-region-abbrevs
For abbrev occurrence in the region, offer to expand it.
The user is asked to type y or n for each occurrence.
A numeric argument means don't query; expand all abbrevs.
Calling from a program, arguments are START END &optional NOQUERY.VBuffer-menu-mode-map
FBuffer-menu-mode
Major mode for editing a list of buffers.
Each line describes one of the buffers in Emacs.
Letters do not insert themselves; instead, they are commands.
m -- mark buffer to be displayed.
q -- select buffer of line point is on.
  Also show buffers marked with m in other windows.
1 -- select that buffer in full-screen window.
2 -- select that buffer in one window,
  together with buffer selected before this one in another window.
f -- select that buffer in place of the buffer menu buffer.
o -- select that buffer in another window,
  so the buffer menu buffer remains visible in its window.
~ -- clear modified-flag on that buffer.
s -- mark that buffer to be saved, and move down.
d or k -- mark that buffer to be deleted, and move down.
C-d -- mark that buffer to be deleted, and move up.
x -- delete or save marked buffers.
u -- remove all kinds of marks from current line.
Delete -- back up a line and remove marks.

Precisely,\{Buffer-menu-mode-map}FBuffer-menu-buffer
Return buffer described by this line of buffer menu.Fbuffer-menu
Make a menu of buffers so you can save, delete or select them.
With argument, show only buffers that are visiting files.
Type ? after invocation to get help on commands available.
Type q immediately to make the buffer menu go away.FBuffer-menu-mark
Mark buffer on this line for being displayed by \[Buffer-menu-select] command.FBuffer-menu-unmark
Cancel all requested operations on buffer on this line.FBuffer-menu-backup-unmark
Move up and cancel all requested operations on buffer on line above.FBuffer-menu-delete
Mark buffer on this line to be deleted by \[Buffer-menu-execute] command.FBuffer-menu-delete-backwards
Mark buffer on this line to be deleted by \[Buffer-menu-execute] command
and then move up one lineFBuffer-menu-save
Mark buffer on this line to be saved by \[Buffer-menu-execute] command.FBuffer-menu-not-modified
Mark buffer on this line as unmodified (no changes to save).FBuffer-menu-execute
Save and/or delete buffers marked with \[Buffer-menu-save] or \[Buffer-menu-delete] commands.FBuffer-menu-select
Select this line's buffer; also display buffers marked with ">".
You can mark buffers with the \[Buffer-menu-mark] command.FBuffer-menu-1-window
Select this line's buffer, alone, in full screen.FBuffer-menu-this-window
Select this line's buffer in this window.FBuffer-menu-other-window
Select this line's buffer in other window, leaving buffer menu visible.FBuffer-menu-2-window
Select this line's buffer, with previous buffer in second window.Fone-window-p
Returns non-nil if there is only one window.
Optional arg NOMINI non-nil means don't count the minibuffer
even if it is active.Fread-quoted-char
Like `read-char', except that if the first character read is an octal
digit, we read up to two more octal digits and return the character
represented by the octal number consisting of those digits.
Optional argument PROMPT specifies a string to use to prompt the user.Ferror
Signal an error, making error message by passing all args to `format'.Fsuppress-keymap
Make MAP override all buffer-modifying commands to be undefined.
Works by knowing which commands are normally buffer-modifying.
Normally also makes digits set numeric arg,
but optional second arg NODIGITS non-nil prevents this.Fsubstitute-key-definition
Replace OLDDEF with NEWDEF for any keys in KEYMAP now defined as OLDDEF.
In other words, OLDDEF is replaced with NEWDEF where ever it appears.Vglobal-map
Default global keymap mapping Emacs keyboard input into commands.
The value is a keymap which is usually (but not necessarily) Emacs's
global map.Vctl-x-map
Default keymap for C-x commands.
The normal global definition of the character C-x indirects to this keymap.Vesc-map
Default keymap for ESC (meta) commands.
The normal global definition of the character ESC indirects to this keymap.Vmouse-map
Keymap for mouse commands from the X window system.Frun-hooks
Takes hook names and runs each one in turn.  Major mode functions use this.
Each argument should be a symbol, a hook variable.
These symbols are processed in the order specified.
If a hook symbol has a non-nil value, that value may be a function
or a list of functions to be called to run the hook.
If the value is a function, it is called with no arguments.
If it is a list, the elements are called, in order, with no arguments.Fmomentary-string-display
Momentarily display STRING in the buffer at POS.
Display remains until next character is typed.
If the char is EXIT-CHAR (optional third arg, default is SPC) it is swallowed;
otherwise it is then available as input (as a command if nothing else).
Display MESSAGE (optional fourth arg) in the echo area.
If MESSAGE is nil, instructions to type EXIT-CHAR are displayed there.Fundo-start
Move undo-pointer to front of undo records.
The next call to undo-more will undo the most recently made change.Fundo-more
Undo back N undo-boundaries beyond what was already undone recently.
Call undo-start to get ready to undo recent changes,
then call undo-more one or more times to undo them.Vemacs-version
Version numbers of this version of Emacs.Vemacs-build-time
Time at which Emacs was dumped out.Femacs-version
Return string describing the version of Emacs that is running.